Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-next-2.6 into for-davem

6 files changed, 337 insertions, 46 deletions

diff --git a/net/wireless/Makefile b/net/wireless/Makefile
index e77e508126fa..55a28ab21db9 100644
--- a/net/wireless/Makefile
+++ b/net/wireless/Makefile
@@ -10,7 +10,7 @@ obj-$(CONFIG_WEXT_SPY) += wext-spy.o
 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
+cfg80211-y += mlme.o ibss.o sme.o chan.o ethtool.o mesh.o
 cfg80211-$(CONFIG_CFG80211_DEBUGFS) += debugfs.o
 cfg80211-$(CONFIG_CFG80211_WEXT) += wext-compat.o wext-sme.o
 cfg80211-$(CONFIG_CFG80211_INTERNAL_REGDB) += regdb.o
diff --git a/net/wireless/core.c b/net/wireless/core.c
index 630bcf0a2f04..79772fcc37bc 100644
--- a/net/wireless/core.c
+++ b/net/wireless/core.c
@@ -332,6 +332,7 @@ struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
         WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
         WARN_ON(ops->add_station && !ops->del_station);
         WARN_ON(ops->add_mpath && !ops->del_mpath);
+        WARN_ON(ops->join_mesh && !ops->leave_mesh);
 
         alloc_size = sizeof(*rdev) + sizeof_priv;
 
@@ -752,6 +753,9 @@ static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
                         cfg80211_mlme_down(rdev, dev);
                         wdev_unlock(wdev);
                         break;
+                case NL80211_IFTYPE_MESH_POINT:
+                        cfg80211_leave_mesh(rdev, dev);
+                        break;
                 default:
                         break;
                 }
@@ -775,20 +779,27 @@ static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
                 }
                 cfg80211_lock_rdev(rdev);
                 mutex_lock(&rdev->devlist_mtx);
-#ifdef CONFIG_CFG80211_WEXT
                 wdev_lock(wdev);
                 switch (wdev->iftype) {
+#ifdef CONFIG_CFG80211_WEXT
                 case NL80211_IFTYPE_ADHOC:
                         cfg80211_ibss_wext_join(rdev, wdev);
                         break;
                 case NL80211_IFTYPE_STATION:
                         cfg80211_mgd_wext_connect(rdev, wdev);
                         break;
+#endif
+                case NL80211_IFTYPE_MESH_POINT:
+                        /* backward compat code ... */
+                        if (wdev->mesh_id_up_len)
+                                __cfg80211_join_mesh(rdev, dev, wdev->ssid,
+                                                     wdev->mesh_id_up_len,
+                                                     &default_mesh_config);
+                        break;
                 default:
                         break;
                 }
                 wdev_unlock(wdev);
-#endif
                 rdev->opencount++;
                 mutex_unlock(&rdev->devlist_mtx);
                 cfg80211_unlock_rdev(rdev);
diff --git a/net/wireless/core.h b/net/wireless/core.h
index ee80ad8dc655..743203bb61ac 100644
--- a/net/wireless/core.h
+++ b/net/wireless/core.h
@@ -285,6 +285,19 @@ void __cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid);
 int cfg80211_ibss_wext_join(struct cfg80211_registered_device *rdev,
                             struct wireless_dev *wdev);
 
+/* mesh */
+extern const struct mesh_config default_mesh_config;
+int __cfg80211_join_mesh(struct cfg80211_registered_device *rdev,
+                         struct net_device *dev,
+                         const u8 *mesh_id, u8 mesh_id_len,
+                         const struct mesh_config *conf);
+int cfg80211_join_mesh(struct cfg80211_registered_device *rdev,
+                       struct net_device *dev,
+                       const u8 *mesh_id, u8 mesh_id_len,
+                       const struct mesh_config *conf);
+int cfg80211_leave_mesh(struct cfg80211_registered_device *rdev,
+                        struct net_device *dev);
+
 /* MLME */
 int __cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
                          struct net_device *dev,
diff --git a/net/wireless/mesh.c b/net/wireless/mesh.c
new file mode 100644
index 000000000000..e0b9747fe50a
--- /dev/null
+++ b/net/wireless/mesh.c
@@ -0,0 +1,140 @@
+#include <linux/ieee80211.h>
+#include <net/cfg80211.h>
+#include "core.h"
+
+/* Default values, timeouts in ms */
+#define MESH_TTL                31
+#define MESH_DEFAULT_ELEMENT_TTL 31
+#define MESH_MAX_RETR           3
+#define MESH_RET_T              100
+#define MESH_CONF_T             100
+#define MESH_HOLD_T             100
+
+#define MESH_PATH_TIMEOUT       5000
+
+/*
+ * Minimum interval between two consecutive PREQs originated by the same
+ * interface
+ */
+#define MESH_PREQ_MIN_INT       10
+#define MESH_DIAM_TRAVERSAL_TIME 50
+
+/*
+ * A path will be refreshed if it is used PATH_REFRESH_TIME milliseconds
+ * before timing out.  This way it will remain ACTIVE and no data frames
+ * will be unnecessarily held in the pending queue.
+ */
+#define MESH_PATH_REFRESH_TIME                  1000
+#define MESH_MIN_DISCOVERY_TIMEOUT (2 * MESH_DIAM_TRAVERSAL_TIME)
+
+/* Default maximum number of established plinks per interface */
+#define MESH_MAX_ESTAB_PLINKS   32
+
+#define MESH_MAX_PREQ_RETRIES   4
+
+
+const struct mesh_config default_mesh_config = {
+        .dot11MeshRetryTimeout = MESH_RET_T,
+        .dot11MeshConfirmTimeout = MESH_CONF_T,
+        .dot11MeshHoldingTimeout = MESH_HOLD_T,
+        .dot11MeshMaxRetries = MESH_MAX_RETR,
+        .dot11MeshTTL = MESH_TTL,
+        .element_ttl = MESH_DEFAULT_ELEMENT_TTL,
+        .auto_open_plinks = true,
+        .dot11MeshMaxPeerLinks = MESH_MAX_ESTAB_PLINKS,
+        .dot11MeshHWMPactivePathTimeout = MESH_PATH_TIMEOUT,
+        .dot11MeshHWMPpreqMinInterval = MESH_PREQ_MIN_INT,
+        .dot11MeshHWMPnetDiameterTraversalTime = MESH_DIAM_TRAVERSAL_TIME,
+        .dot11MeshHWMPmaxPREQretries = MESH_MAX_PREQ_RETRIES,
+        .path_refresh_time = MESH_PATH_REFRESH_TIME,
+        .min_discovery_timeout = MESH_MIN_DISCOVERY_TIMEOUT,
+};
+
+
+int __cfg80211_join_mesh(struct cfg80211_registered_device *rdev,
+                         struct net_device *dev,
+                         const u8 *mesh_id, u8 mesh_id_len,
+                         const struct mesh_config *conf)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct mesh_setup setup = {
+                .mesh_id = mesh_id,
+                .mesh_id_len = mesh_id_len,
+        };
+        int err;
+
+        BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN != IEEE80211_MAX_MESH_ID_LEN);
+
+        ASSERT_WDEV_LOCK(wdev);
+
+        if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
+                return -EOPNOTSUPP;
+
+        if (wdev->mesh_id_len)
+                return -EALREADY;
+
+        if (!mesh_id_len)
+                return -EINVAL;
+
+        if (!rdev->ops->join_mesh)
+                return -EOPNOTSUPP;
+
+        err = rdev->ops->join_mesh(&rdev->wiphy, dev, conf, &setup);
+        if (!err) {
+                memcpy(wdev->ssid, mesh_id, mesh_id_len);
+                wdev->mesh_id_len = mesh_id_len;
+        }
+
+        return err;
+}
+
+int cfg80211_join_mesh(struct cfg80211_registered_device *rdev,
+                       struct net_device *dev,
+                       const u8 *mesh_id, u8 mesh_id_len,
+                       const struct mesh_config *conf)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        int err;
+
+        wdev_lock(wdev);
+        err = __cfg80211_join_mesh(rdev, dev, mesh_id, mesh_id_len, conf);
+        wdev_unlock(wdev);
+
+        return err;
+}
+
+static int __cfg80211_leave_mesh(struct cfg80211_registered_device *rdev,
+                                 struct net_device *dev)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        int err;
+
+        ASSERT_WDEV_LOCK(wdev);
+
+        if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
+                return -EOPNOTSUPP;
+
+        if (!rdev->ops->leave_mesh)
+                return -EOPNOTSUPP;
+
+        if (!wdev->mesh_id_len)
+                return -ENOTCONN;
+
+        err = rdev->ops->leave_mesh(&rdev->wiphy, dev);
+        if (!err)
+                wdev->mesh_id_len = 0;
+        return err;
+}
+
+int cfg80211_leave_mesh(struct cfg80211_registered_device *rdev,
+                        struct net_device *dev)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        int err;
+
+        wdev_lock(wdev);
+        err = __cfg80211_leave_mesh(rdev, dev);
+        wdev_unlock(wdev);
+
+        return err;
+}
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index 960be4e650f0..c3f80e565365 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -121,6 +121,7 @@ static const struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] = {
         [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
         [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
                                            .len = NL80211_MAX_SUPP_RATES },
+        [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
 
         [NL80211_ATTR_MESH_PARAMS] = { .type = NLA_NESTED },
 
@@ -661,13 +662,14 @@ static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
         CMD(add_beacon, NEW_BEACON);
         CMD(add_station, NEW_STATION);
         CMD(add_mpath, NEW_MPATH);
-        CMD(set_mesh_params, SET_MESH_PARAMS);
+        CMD(update_mesh_params, SET_MESH_PARAMS);
         CMD(change_bss, SET_BSS);
         CMD(auth, AUTHENTICATE);
         CMD(assoc, ASSOCIATE);
         CMD(deauth, DEAUTHENTICATE);
         CMD(disassoc, DISASSOCIATE);
         CMD(join_ibss, JOIN_IBSS);
+        CMD(join_mesh, JOIN_MESH);
         CMD(set_pmksa, SET_PMKSA);
         CMD(del_pmksa, DEL_PMKSA);
         CMD(flush_pmksa, FLUSH_PMKSA);
@@ -1324,11 +1326,21 @@ static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
         }
 
         if (info->attrs[NL80211_ATTR_MESH_ID]) {
+                struct wireless_dev *wdev = dev->ieee80211_ptr;
+
                 if (ntype != NL80211_IFTYPE_MESH_POINT)
                         return -EINVAL;
-                params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
-                params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
-                change = true;
+                if (netif_running(dev))
+                        return -EBUSY;
+
+                wdev_lock(wdev);
+                BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
+                             IEEE80211_MAX_MESH_ID_LEN);
+                wdev->mesh_id_up_len =
+                        nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
+                memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
+                       wdev->mesh_id_up_len);
+                wdev_unlock(wdev);
         }
 
         if (info->attrs[NL80211_ATTR_4ADDR]) {
@@ -1368,6 +1380,7 @@ static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
 {
         struct cfg80211_registered_device *rdev = info->user_ptr[0];
         struct vif_params params;
+        struct net_device *dev;
         int err;
         enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
         u32 flags;
@@ -1387,12 +1400,6 @@ static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
             !(rdev->wiphy.interface_modes & (1 << type)))
                 return -EOPNOTSUPP;
 
-        if (type == NL80211_IFTYPE_MESH_POINT &&
-            info->attrs[NL80211_ATTR_MESH_ID]) {
-                params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
-                params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
-        }
-
         if (info->attrs[NL80211_ATTR_4ADDR]) {
                 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
                 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
@@ -1403,11 +1410,27 @@ static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
         err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
                                   info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
                                   &flags);
-        err = rdev->ops->add_virtual_intf(&rdev->wiphy,
+        dev = rdev->ops->add_virtual_intf(&rdev->wiphy,
                 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
                 type, err ? NULL : &flags, &params);
+        if (IS_ERR(dev))
+                return PTR_ERR(dev);
 
-        return err;
+        if (type == NL80211_IFTYPE_MESH_POINT &&
+            info->attrs[NL80211_ATTR_MESH_ID]) {
+                struct wireless_dev *wdev = dev->ieee80211_ptr;
+
+                wdev_lock(wdev);
+                BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
+                             IEEE80211_MAX_MESH_ID_LEN);
+                wdev->mesh_id_up_len =
+                        nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
+                memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
+                       wdev->mesh_id_up_len);
+                wdev_unlock(wdev);
+        }
+
+        return 0;
 }
 
 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
@@ -1874,6 +1897,9 @@ static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
         if (sinfo->filled & STATION_INFO_SIGNAL)
                 NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL,
                            sinfo->signal);
+        if (sinfo->filled & STATION_INFO_SIGNAL_AVG)
+                NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL_AVG,
+                           sinfo->signal_avg);
         if (sinfo->filled & STATION_INFO_TX_BITRATE) {
                 txrate = nla_nest_start(msg, NL80211_STA_INFO_TX_BITRATE);
                 if (!txrate)
@@ -2437,6 +2463,7 @@ static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
         params.use_short_preamble = -1;
         params.use_short_slot_time = -1;
         params.ap_isolate = -1;
+        params.ht_opmode = -1;
 
         if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
                 params.use_cts_prot =
@@ -2455,6 +2482,9 @@ static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
         }
         if (info->attrs[NL80211_ATTR_AP_ISOLATE])
                 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
+        if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
+                params.ht_opmode =
+                        nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
 
         if (!rdev->ops->change_bss)
                 return -EOPNOTSUPP;
@@ -2540,21 +2570,32 @@ static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
 }
 
 static int nl80211_get_mesh_params(struct sk_buff *skb,
-        struct genl_info *info)
+                                   struct genl_info *info)
 {
         struct cfg80211_registered_device *rdev = info->user_ptr[0];
-        struct mesh_config cur_params;
-        int err;
         struct net_device *dev = info->user_ptr[1];
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct mesh_config cur_params;
+        int err = 0;
         void *hdr;
         struct nlattr *pinfoattr;
         struct sk_buff *msg;
 
+        if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
+                return -EOPNOTSUPP;
+
         if (!rdev->ops->get_mesh_params)
                 return -EOPNOTSUPP;
 
-        /* Get the mesh params */
-        err = rdev->ops->get_mesh_params(&rdev->wiphy, dev, &cur_params);
+        wdev_lock(wdev);
+        /* If not connected, get default parameters */
+        if (!wdev->mesh_id_len)
+                memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
+        else
+                err = rdev->ops->get_mesh_params(&rdev->wiphy, dev,
+                                                 &cur_params);
+        wdev_unlock(wdev);
+
         if (err)
                 return err;
 
@@ -2582,6 +2623,8 @@ static int nl80211_get_mesh_params(struct sk_buff *skb,
                         cur_params.dot11MeshMaxRetries);
         NLA_PUT_U8(msg, NL80211_MESHCONF_TTL,
                         cur_params.dot11MeshTTL);
+        NLA_PUT_U8(msg, NL80211_MESHCONF_ELEMENT_TTL,
+                        cur_params.element_ttl);
         NLA_PUT_U8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
                         cur_params.auto_open_plinks);
         NLA_PUT_U8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
@@ -2608,14 +2651,6 @@ static int nl80211_get_mesh_params(struct sk_buff *skb,
         return -ENOBUFS;
 }
 
-#define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
-do {\
-        if (table[attr_num]) {\
-                cfg.param = nla_fn(table[attr_num]); \
-                mask |= (1 << (attr_num - 1)); \
-        } \
-} while (0);\
-
 static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
         [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
         [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
@@ -2623,6 +2658,7 @@ static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_A
         [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
         [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
         [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
+        [NL80211_MESHCONF_ELEMENT_TTL] = { .type = NLA_U8 },
         [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
 
         [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
@@ -2633,31 +2669,34 @@ static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_A
         [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
 };
 
-static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info)
+static int nl80211_parse_mesh_params(struct genl_info *info,
+                                     struct mesh_config *cfg,
+                                     u32 *mask_out)
 {
-        u32 mask;
-        struct cfg80211_registered_device *rdev = info->user_ptr[0];
-        struct net_device *dev = info->user_ptr[1];
-        struct mesh_config cfg;
         struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
-        struct nlattr *parent_attr;
+        u32 mask = 0;
+
+#define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
+do {\
+        if (table[attr_num]) {\
+                cfg->param = nla_fn(table[attr_num]); \
+                mask |= (1 << (attr_num - 1)); \
+        } \
+} while (0);\
+
 
-        parent_attr = info->attrs[NL80211_ATTR_MESH_PARAMS];
-        if (!parent_attr)
+        if (!info->attrs[NL80211_ATTR_MESH_PARAMS])
                 return -EINVAL;
         if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
-                        parent_attr, nl80211_meshconf_params_policy))
+                             info->attrs[NL80211_ATTR_MESH_PARAMS],
+                             nl80211_meshconf_params_policy))
                 return -EINVAL;
 
-        if (!rdev->ops->set_mesh_params)
-                return -EOPNOTSUPP;
-
         /* This makes sure that there aren't more than 32 mesh config
          * parameters (otherwise our bitfield scheme would not work.) */
         BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
 
         /* Fill in the params struct */
-        mask = 0;
         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout,
                         mask, NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout,
@@ -2670,6 +2709,8 @@ static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info)
                         mask, NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL,
                         mask, NL80211_MESHCONF_TTL, nla_get_u8);
+        FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl,
+                        mask, NL80211_MESHCONF_ELEMENT_TTL, nla_get_u8);
         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks,
                         mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS, nla_get_u8);
         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries,
@@ -2695,11 +2736,45 @@ static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info)
                         NL80211_MESHCONF_HWMP_ROOTMODE,
                         nla_get_u8);
 
-        /* Apply changes */
-        return rdev->ops->set_mesh_params(&rdev->wiphy, dev, &cfg, mask);
-}
+        if (mask_out)
+                *mask_out = mask;
+        return 0;
 
 #undef FILL_IN_MESH_PARAM_IF_SET
+}
+
+static int nl80211_update_mesh_params(struct sk_buff *skb,
+                                      struct genl_info *info)
+{
+        struct cfg80211_registered_device *rdev = info->user_ptr[0];
+        struct net_device *dev = info->user_ptr[1];
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct mesh_config cfg;
+        u32 mask;
+        int err;
+
+        if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
+                return -EOPNOTSUPP;
+
+        if (!rdev->ops->update_mesh_params)
+                return -EOPNOTSUPP;
+
+        err = nl80211_parse_mesh_params(info, &cfg, &mask);
+        if (err)
+                return err;
+
+        wdev_lock(wdev);
+        if (!wdev->mesh_id_len)
+                err = -ENOLINK;
+
+        if (!err)
+                err = rdev->ops->update_mesh_params(&rdev->wiphy, dev,
+                                                    mask, &cfg);
+
+        wdev_unlock(wdev);
+
+        return err;
+}
 
 static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
 {
@@ -4482,6 +4557,41 @@ out:
         return err;
 }
 
+static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
+{
+        struct cfg80211_registered_device *rdev = info->user_ptr[0];
+        struct net_device *dev = info->user_ptr[1];
+        struct mesh_config cfg;
+        int err;
+
+        /* start with default */
+        memcpy(&cfg, &default_mesh_config, sizeof(cfg));
+
+        if (info->attrs[NL80211_ATTR_MESH_PARAMS]) {
+                /* and parse parameters if given */
+                err = nl80211_parse_mesh_params(info, &cfg, NULL);
+                if (err)
+                        return err;
+        }
+
+        if (!info->attrs[NL80211_ATTR_MESH_ID] ||
+            !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
+                return -EINVAL;
+
+        return cfg80211_join_mesh(rdev, dev,
+                                  nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
+                                  nla_len(info->attrs[NL80211_ATTR_MESH_ID]),
+                                  &cfg);
+}
+
+static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
+{
+        struct cfg80211_registered_device *rdev = info->user_ptr[0];
+        struct net_device *dev = info->user_ptr[1];
+
+        return cfg80211_leave_mesh(rdev, dev);
+}
+
 #define NL80211_FLAG_NEED_WIPHY         0x01
 #define NL80211_FLAG_NEED_NETDEV        0x02
 #define NL80211_FLAG_NEED_RTNL          0x04
@@ -4746,10 +4856,10 @@ static struct genl_ops nl80211_ops[] = {
         },
         {
                 .cmd = NL80211_CMD_SET_MESH_PARAMS,
-                .doit = nl80211_set_mesh_params,
+                .doit = nl80211_update_mesh_params,
                 .policy = nl80211_policy,
                 .flags = GENL_ADMIN_PERM,
-                .internal_flags = NL80211_FLAG_NEED_NETDEV |
+                .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
                                   NL80211_FLAG_NEED_RTNL,
         },
         {
@@ -4964,6 +5074,22 @@ static struct genl_ops nl80211_ops[] = {
                 .internal_flags = NL80211_FLAG_NEED_NETDEV |
                                   NL80211_FLAG_NEED_RTNL,
         },
+        {
+                .cmd = NL80211_CMD_JOIN_MESH,
+                .doit = nl80211_join_mesh,
+                .policy = nl80211_policy,
+                .flags = GENL_ADMIN_PERM,
+                .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
+                                  NL80211_FLAG_NEED_RTNL,
+        },
+        {
+                .cmd = NL80211_CMD_LEAVE_MESH,
+                .doit = nl80211_leave_mesh,
+                .policy = nl80211_policy,
+                .flags = GENL_ADMIN_PERM,
+                .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
+                                  NL80211_FLAG_NEED_RTNL,
+        },
 };
 
 static struct genl_multicast_group nl80211_mlme_mcgrp = {
diff --git a/net/wireless/util.c b/net/wireless/util.c
index fee020b15a4e..4de624ca4c63 100644
--- a/net/wireless/util.c
+++ b/net/wireless/util.c
@@ -792,6 +792,7 @@ int cfg80211_change_iface(struct cfg80211_registered_device *rdev,
 
         if (ntype != otype) {
                 dev->ieee80211_ptr->use_4addr = false;
+                dev->ieee80211_ptr->mesh_id_up_len = 0;
 
                 switch (otype) {
                 case NL80211_IFTYPE_ADHOC: