Merge commit 'v3.17' into next

1 files changed, 242 insertions, 338 deletions

diff --git a/net/hsr/hsr_device.c b/net/hsr/hsr_device.c
index e5302b7f7ca9..a138d75751df 100644
--- a/net/hsr/hsr_device.c
+++ b/net/hsr/hsr_device.c
@@ -1,4 +1,4 @@
-/* Copyright 2011-2013 Autronica Fire and Security AS
+/* Copyright 2011-2014 Autronica Fire and Security AS
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
@@ -6,7 +6,7 @@
  * any later version.
  *
  * Author(s):
- *      2011-2013 Arvid Brodin, arvid.brodin@xdin.com
+ *      2011-2014 Arvid Brodin, arvid.brodin@alten.se
  *
  * This file contains device methods for creating, using and destroying
  * virtual HSR devices.
@@ -15,12 +15,13 @@
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
 #include <linux/etherdevice.h>
-#include <linux/if_arp.h>
 #include <linux/rtnetlink.h>
 #include <linux/pkt_sched.h>
 #include "hsr_device.h"
+#include "hsr_slave.h"
 #include "hsr_framereg.h"
 #include "hsr_main.h"
+#include "hsr_forward.h"
 
 
 static bool is_admin_up(struct net_device *dev)
@@ -45,75 +46,108 @@ static void __hsr_set_operstate(struct net_device *dev, int transition)
         }
 }
 
-void hsr_set_operstate(struct net_device *hsr_dev, struct net_device *slave1,
-                       struct net_device *slave2)
+static void hsr_set_operstate(struct hsr_port *master, bool has_carrier)
 {
-        if (!is_admin_up(hsr_dev)) {
-                __hsr_set_operstate(hsr_dev, IF_OPER_DOWN);
+        if (!is_admin_up(master->dev)) {
+                __hsr_set_operstate(master->dev, IF_OPER_DOWN);
                 return;
         }
 
-        if (is_slave_up(slave1) || is_slave_up(slave2))
-                __hsr_set_operstate(hsr_dev, IF_OPER_UP);
+        if (has_carrier)
+                __hsr_set_operstate(master->dev, IF_OPER_UP);
         else
-                __hsr_set_operstate(hsr_dev, IF_OPER_LOWERLAYERDOWN);
+                __hsr_set_operstate(master->dev, IF_OPER_LOWERLAYERDOWN);
 }
 
-void hsr_set_carrier(struct net_device *hsr_dev, struct net_device *slave1,
-                     struct net_device *slave2)
+static bool hsr_check_carrier(struct hsr_port *master)
 {
-        if (is_slave_up(slave1) || is_slave_up(slave2))
-                netif_carrier_on(hsr_dev);
+        struct hsr_port *port;
+        bool has_carrier;
+
+        has_carrier = false;
+
+        rcu_read_lock();
+        hsr_for_each_port(master->hsr, port)
+                if ((port->type != HSR_PT_MASTER) && is_slave_up(port->dev)) {
+                        has_carrier = true;
+                        break;
+                }
+        rcu_read_unlock();
+
+        if (has_carrier)
+                netif_carrier_on(master->dev);
         else
-                netif_carrier_off(hsr_dev);
+                netif_carrier_off(master->dev);
+
+        return has_carrier;
 }
 
 
-void hsr_check_announce(struct net_device *hsr_dev, int old_operstate)
+static void hsr_check_announce(struct net_device *hsr_dev,
+                               unsigned char old_operstate)
 {
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
 
-        hsr_priv = netdev_priv(hsr_dev);
+        hsr = netdev_priv(hsr_dev);
 
         if ((hsr_dev->operstate == IF_OPER_UP) && (old_operstate != IF_OPER_UP)) {
                 /* Went up */
-                hsr_priv->announce_count = 0;
-                hsr_priv->announce_timer.expires = jiffies +
+                hsr->announce_count = 0;
+                hsr->announce_timer.expires = jiffies +
                                 msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL);
-                add_timer(&hsr_priv->announce_timer);
+                add_timer(&hsr->announce_timer);
         }
 
         if ((hsr_dev->operstate != IF_OPER_UP) && (old_operstate == IF_OPER_UP))
                 /* Went down */
-                del_timer(&hsr_priv->announce_timer);
+                del_timer(&hsr->announce_timer);
 }
 
-
-int hsr_get_max_mtu(struct hsr_priv *hsr_priv)
+void hsr_check_carrier_and_operstate(struct hsr_priv *hsr)
 {
-        int mtu_max;
-
-        if (hsr_priv->slave[0] && hsr_priv->slave[1])
-                mtu_max = min(hsr_priv->slave[0]->mtu, hsr_priv->slave[1]->mtu);
-        else if (hsr_priv->slave[0])
-                mtu_max = hsr_priv->slave[0]->mtu;
-        else if (hsr_priv->slave[1])
-                mtu_max = hsr_priv->slave[1]->mtu;
-        else
-                mtu_max = HSR_TAGLEN;
+        struct hsr_port *master;
+        unsigned char old_operstate;
+        bool has_carrier;
 
-        return mtu_max - HSR_TAGLEN;
+        master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
+        /* netif_stacked_transfer_operstate() cannot be used here since
+         * it doesn't set IF_OPER_LOWERLAYERDOWN (?)
+         */
+        old_operstate = master->dev->operstate;
+        has_carrier = hsr_check_carrier(master);
+        hsr_set_operstate(master, has_carrier);
+        hsr_check_announce(master->dev, old_operstate);
 }
 
+int hsr_get_max_mtu(struct hsr_priv *hsr)
+{
+        unsigned int mtu_max;
+        struct hsr_port *port;
+
+        mtu_max = ETH_DATA_LEN;
+        rcu_read_lock();
+        hsr_for_each_port(hsr, port)
+                if (port->type != HSR_PT_MASTER)
+                        mtu_max = min(port->dev->mtu, mtu_max);
+        rcu_read_unlock();
+
+        if (mtu_max < HSR_HLEN)
+                return 0;
+        return mtu_max - HSR_HLEN;
+}
+
+
 static int hsr_dev_change_mtu(struct net_device *dev, int new_mtu)
 {
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
+        struct hsr_port *master;
 
-        hsr_priv = netdev_priv(dev);
+        hsr = netdev_priv(dev);
+        master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
 
-        if (new_mtu > hsr_get_max_mtu(hsr_priv)) {
-                netdev_info(hsr_priv->dev, "A HSR master's MTU cannot be greater than the smallest MTU of its slaves minus the HSR Tag length (%d octets).\n",
-                            HSR_TAGLEN);
+        if (new_mtu > hsr_get_max_mtu(hsr)) {
+                netdev_info(master->dev, "A HSR master's MTU cannot be greater than the smallest MTU of its slaves minus the HSR Tag length (%d octets).\n",
+                            HSR_HLEN);
                 return -EINVAL;
         }
 
@@ -124,164 +158,95 @@ static int hsr_dev_change_mtu(struct net_device *dev, int new_mtu)
 
 static int hsr_dev_open(struct net_device *dev)
 {
-        struct hsr_priv *hsr_priv;
-        int i;
-        char *slave_name;
+        struct hsr_priv *hsr;
+        struct hsr_port *port;
+        char designation;
 
-        hsr_priv = netdev_priv(dev);
+        hsr = netdev_priv(dev);
+        designation = '\0';
 
-        for (i = 0; i < HSR_MAX_SLAVE; i++) {
-                if (hsr_priv->slave[i])
-                        slave_name = hsr_priv->slave[i]->name;
-                else
-                        slave_name = "null";
-
-                if (!is_slave_up(hsr_priv->slave[i]))
-                        netdev_warn(dev, "Slave %c (%s) is not up; please bring it up to get a working HSR network\n",
-                                    'A' + i, slave_name);
+        rcu_read_lock();
+        hsr_for_each_port(hsr, port) {
+                if (port->type == HSR_PT_MASTER)
+                        continue;
+                switch (port->type) {
+                case HSR_PT_SLAVE_A:
+                        designation = 'A';
+                        break;
+                case HSR_PT_SLAVE_B:
+                        designation = 'B';
+                        break;
+                default:
+                        designation = '?';
+                }
+                if (!is_slave_up(port->dev))
+                        netdev_warn(dev, "Slave %c (%s) is not up; please bring it up to get a fully working HSR network\n",
+                                    designation, port->dev->name);
         }
+        rcu_read_unlock();
+
+        if (designation == '\0')
+                netdev_warn(dev, "No slave devices configured\n");
 
         return 0;
 }
 
+
 static int hsr_dev_close(struct net_device *dev)
 {
-        /* Nothing to do here. We could try to restore the state of the slaves
-         * to what they were before being changed by the hsr master dev's state,
-         * but they might have been changed manually in the mean time too, so
-         * taking them up or down here might be confusing and is probably not a
-         * good idea.
-         */
+        /* Nothing to do here. */
         return 0;
 }
 
 
-static void hsr_fill_tag(struct hsr_ethhdr *hsr_ethhdr, struct hsr_priv *hsr_priv)
+static netdev_features_t hsr_features_recompute(struct hsr_priv *hsr,
+                                                netdev_features_t features)
 {
-        unsigned long irqflags;
+        netdev_features_t mask;
+        struct hsr_port *port;
 
-        /* IEC 62439-1:2010, p 48, says the 4-bit "path" field can take values
-         * between 0001-1001 ("ring identifier", for regular HSR frames),
-         * or 1111 ("HSR management", supervision frames). Unfortunately, the
-         * spec writers forgot to explain what a "ring identifier" is, or
-         * how it is used. So we just set this to 0001 for regular frames,
-         * and 1111 for supervision frames.
-         */
-        set_hsr_tag_path(&hsr_ethhdr->hsr_tag, 0x1);
+        mask = features;
 
-        /* IEC 62439-1:2010, p 12: "The link service data unit in an Ethernet
-         * frame is the content of the frame located between the Length/Type
-         * field and the Frame Check Sequence."
+        /* Mask out all features that, if supported by one device, should be
+         * enabled for all devices (see NETIF_F_ONE_FOR_ALL).
          *
-         * IEC 62439-3, p 48, specifies the "original LPDU" to include the
-         * original "LT" field (what "LT" means is not explained anywhere as
-         * far as I can see - perhaps "Length/Type"?). So LSDU_size might
-         * equal original length + 2.
-         *   Also, the fact that this field is not used anywhere (might be used
-         * by a RedBox connecting HSR and PRP nets?) means I cannot test its
-         * correctness. Instead of guessing, I set this to 0 here, to make any
-         * problems immediately apparent. Anyone using this driver with PRP/HSR
-         * RedBoxes might need to fix this...
+         * Anything that's off in mask will not be enabled - so only things
+         * that were in features originally, and also is in NETIF_F_ONE_FOR_ALL,
+         * may become enabled.
          */
-        set_hsr_tag_LSDU_size(&hsr_ethhdr->hsr_tag, 0);
-
-        spin_lock_irqsave(&hsr_priv->seqnr_lock, irqflags);
-        hsr_ethhdr->hsr_tag.sequence_nr = htons(hsr_priv->sequence_nr);
-        hsr_priv->sequence_nr++;
-        spin_unlock_irqrestore(&hsr_priv->seqnr_lock, irqflags);
+        features &= ~NETIF_F_ONE_FOR_ALL;
+        hsr_for_each_port(hsr, port)
+                features = netdev_increment_features(features,
+                                                     port->dev->features,
+                                                     mask);
 
-        hsr_ethhdr->hsr_tag.encap_proto = hsr_ethhdr->ethhdr.h_proto;
-
-        hsr_ethhdr->ethhdr.h_proto = htons(ETH_P_PRP);
+        return features;
 }
 
-static int slave_xmit(struct sk_buff *skb, struct hsr_priv *hsr_priv,
-                      enum hsr_dev_idx dev_idx)
+static netdev_features_t hsr_fix_features(struct net_device *dev,
+                                          netdev_features_t features)
 {
-        struct hsr_ethhdr *hsr_ethhdr;
-
-        hsr_ethhdr = (struct hsr_ethhdr *) skb->data;
+        struct hsr_priv *hsr = netdev_priv(dev);
 
-        skb->dev = hsr_priv->slave[dev_idx];
-
-        hsr_addr_subst_dest(hsr_priv, &hsr_ethhdr->ethhdr, dev_idx);
-
-        /* Address substitution (IEC62439-3 pp 26, 50): replace mac
-         * address of outgoing frame with that of the outgoing slave's.
-         */
-        ether_addr_copy(hsr_ethhdr->ethhdr.h_source, skb->dev->dev_addr);
-
-        return dev_queue_xmit(skb);
+        return hsr_features_recompute(hsr, features);
 }
 
 
 static int hsr_dev_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-        struct hsr_priv *hsr_priv;
-        struct hsr_ethhdr *hsr_ethhdr;
-        struct sk_buff *skb2;
-        int res1, res2;
-
-        hsr_priv = netdev_priv(dev);
-        hsr_ethhdr = (struct hsr_ethhdr *) skb->data;
-
-        if ((skb->protocol != htons(ETH_P_PRP)) ||
-            (hsr_ethhdr->ethhdr.h_proto != htons(ETH_P_PRP))) {
-                hsr_fill_tag(hsr_ethhdr, hsr_priv);
-                skb->protocol = htons(ETH_P_PRP);
-        }
-
-        skb2 = pskb_copy(skb, GFP_ATOMIC);
-
-        res1 = NET_XMIT_DROP;
-        if (likely(hsr_priv->slave[HSR_DEV_SLAVE_A]))
-                res1 = slave_xmit(skb, hsr_priv, HSR_DEV_SLAVE_A);
+        struct hsr_priv *hsr = netdev_priv(dev);
+        struct hsr_port *master;
 
-        res2 = NET_XMIT_DROP;
-        if (likely(skb2 && hsr_priv->slave[HSR_DEV_SLAVE_B]))
-                res2 = slave_xmit(skb2, hsr_priv, HSR_DEV_SLAVE_B);
-
-        if (likely(res1 == NET_XMIT_SUCCESS || res1 == NET_XMIT_CN ||
-                   res2 == NET_XMIT_SUCCESS || res2 == NET_XMIT_CN)) {
-                hsr_priv->dev->stats.tx_packets++;
-                hsr_priv->dev->stats.tx_bytes += skb->len;
-        } else {
-                hsr_priv->dev->stats.tx_dropped++;
-        }
+        master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
+        skb->dev = master->dev;
+        hsr_forward_skb(skb, master);
 
         return NETDEV_TX_OK;
 }
 
 
-static int hsr_header_create(struct sk_buff *skb, struct net_device *dev,
-                             unsigned short type, const void *daddr,
-                             const void *saddr, unsigned int len)
-{
-        int res;
-
-        /* Make room for the HSR tag now. We will fill it in later (in
-         * hsr_dev_xmit)
-         */
-        if (skb_headroom(skb) < HSR_TAGLEN + ETH_HLEN)
-                return -ENOBUFS;
-        skb_push(skb, HSR_TAGLEN);
-
-        /* To allow VLAN/HSR combos we should probably use
-         * res = dev_hard_header(skb, dev, type, daddr, saddr, len + HSR_TAGLEN);
-         * here instead. It would require other changes too, though - e.g.
-         * separate headers for each slave etc...
-         */
-        res = eth_header(skb, dev, type, daddr, saddr, len + HSR_TAGLEN);
-        if (res <= 0)
-                return res;
-        skb_reset_mac_header(skb);
-
-        return res + HSR_TAGLEN;
-}
-
-
 static const struct header_ops hsr_header_ops = {
-        .create  = hsr_header_create,
+        .create  = eth_header,
         .parse   = eth_header_parse,
 };
 
@@ -291,67 +256,63 @@ static const struct header_ops hsr_header_ops = {
  */
 static int hsr_pad(int size)
 {
-        const int min_size = ETH_ZLEN - HSR_TAGLEN - ETH_HLEN;
+        const int min_size = ETH_ZLEN - HSR_HLEN - ETH_HLEN;
 
         if (size >= min_size)
                 return size;
         return min_size;
 }
 
-static void send_hsr_supervision_frame(struct net_device *hsr_dev, u8 type)
+static void send_hsr_supervision_frame(struct hsr_port *master, u8 type)
 {
-        struct hsr_priv *hsr_priv;
         struct sk_buff *skb;
         int hlen, tlen;
         struct hsr_sup_tag *hsr_stag;
         struct hsr_sup_payload *hsr_sp;
         unsigned long irqflags;
 
-        hlen = LL_RESERVED_SPACE(hsr_dev);
-        tlen = hsr_dev->needed_tailroom;
+        hlen = LL_RESERVED_SPACE(master->dev);
+        tlen = master->dev->needed_tailroom;
         skb = alloc_skb(hsr_pad(sizeof(struct hsr_sup_payload)) + hlen + tlen,
                         GFP_ATOMIC);
 
         if (skb == NULL)
                 return;
 
-        hsr_priv = netdev_priv(hsr_dev);
-
         skb_reserve(skb, hlen);
 
-        skb->dev = hsr_dev;
+        skb->dev = master->dev;
         skb->protocol = htons(ETH_P_PRP);
         skb->priority = TC_PRIO_CONTROL;
 
         if (dev_hard_header(skb, skb->dev, ETH_P_PRP,
-                            hsr_priv->sup_multicast_addr,
-                            skb->dev->dev_addr, skb->len) < 0)
+                            master->hsr->sup_multicast_addr,
+                            skb->dev->dev_addr, skb->len) <= 0)
                 goto out;
+        skb_reset_mac_header(skb);
 
-        skb_pull(skb, sizeof(struct ethhdr));
-        hsr_stag = (typeof(hsr_stag)) skb->data;
+        hsr_stag = (typeof(hsr_stag)) skb_put(skb, sizeof(*hsr_stag));
 
         set_hsr_stag_path(hsr_stag, 0xf);
         set_hsr_stag_HSR_Ver(hsr_stag, 0);
 
-        spin_lock_irqsave(&hsr_priv->seqnr_lock, irqflags);
-        hsr_stag->sequence_nr = htons(hsr_priv->sequence_nr);
-        hsr_priv->sequence_nr++;
-        spin_unlock_irqrestore(&hsr_priv->seqnr_lock, irqflags);
+        spin_lock_irqsave(&master->hsr->seqnr_lock, irqflags);
+        hsr_stag->sequence_nr = htons(master->hsr->sequence_nr);
+        master->hsr->sequence_nr++;
+        spin_unlock_irqrestore(&master->hsr->seqnr_lock, irqflags);
 
         hsr_stag->HSR_TLV_Type = type;
         hsr_stag->HSR_TLV_Length = 12;
 
-        skb_push(skb, sizeof(struct ethhdr));
-
         /* Payload: MacAddressA */
         hsr_sp = (typeof(hsr_sp)) skb_put(skb, sizeof(*hsr_sp));
-        ether_addr_copy(hsr_sp->MacAddressA, hsr_dev->dev_addr);
+        ether_addr_copy(hsr_sp->MacAddressA, master->dev->dev_addr);
 
-        dev_queue_xmit(skb);
+        hsr_forward_skb(skb, master);
         return;
 
 out:
+        WARN_ON_ONCE("HSR: Could not send supervision frame\n");
         kfree_skb(skb);
 }
 
@@ -360,59 +321,32 @@ out:
  */
 static void hsr_announce(unsigned long data)
 {
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
+        struct hsr_port *master;
 
-        hsr_priv = (struct hsr_priv *) data;
+        hsr = (struct hsr_priv *) data;
 
-        if (hsr_priv->announce_count < 3) {
-                send_hsr_supervision_frame(hsr_priv->dev, HSR_TLV_ANNOUNCE);
-                hsr_priv->announce_count++;
+        rcu_read_lock();
+        master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
+
+        if (hsr->announce_count < 3) {
+                send_hsr_supervision_frame(master, HSR_TLV_ANNOUNCE);
+                hsr->announce_count++;
         } else {
-                send_hsr_supervision_frame(hsr_priv->dev, HSR_TLV_LIFE_CHECK);
+                send_hsr_supervision_frame(master, HSR_TLV_LIFE_CHECK);
         }
 
-        if (hsr_priv->announce_count < 3)
-                hsr_priv->announce_timer.expires = jiffies +
+        if (hsr->announce_count < 3)
+                hsr->announce_timer.expires = jiffies +
                                 msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL);
         else
-                hsr_priv->announce_timer.expires = jiffies +
+                hsr->announce_timer.expires = jiffies +
                                 msecs_to_jiffies(HSR_LIFE_CHECK_INTERVAL);
 
-        if (is_admin_up(hsr_priv->dev))
-                add_timer(&hsr_priv->announce_timer);
-}
-
-
-static void restore_slaves(struct net_device *hsr_dev)
-{
-        struct hsr_priv *hsr_priv;
-        int i;
-        int res;
-
-        hsr_priv = netdev_priv(hsr_dev);
-
-        rtnl_lock();
-
-        /* Restore promiscuity */
-        for (i = 0; i < HSR_MAX_SLAVE; i++) {
-                if (!hsr_priv->slave[i])
-                        continue;
-                res = dev_set_promiscuity(hsr_priv->slave[i], -1);
-                if (res)
-                        netdev_info(hsr_dev,
-                                    "Cannot restore slave promiscuity (%s, %d)\n",
-                                    hsr_priv->slave[i]->name, res);
-        }
-
-        rtnl_unlock();
-}
-
-static void reclaim_hsr_dev(struct rcu_head *rh)
-{
-        struct hsr_priv *hsr_priv;
+        if (is_admin_up(master->dev))
+                add_timer(&hsr->announce_timer);
 
-        hsr_priv = container_of(rh, struct hsr_priv, rcu_head);
-        free_netdev(hsr_priv->dev);
+        rcu_read_unlock();
 }
 
 
@@ -421,14 +355,18 @@ static void reclaim_hsr_dev(struct rcu_head *rh)
  */
 static void hsr_dev_destroy(struct net_device *hsr_dev)
 {
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
+        struct hsr_port *port;
 
-        hsr_priv = netdev_priv(hsr_dev);
+        hsr = netdev_priv(hsr_dev);
+        hsr_for_each_port(hsr, port)
+                hsr_del_port(port);
 
-        del_timer(&hsr_priv->announce_timer);
-        unregister_hsr_master(hsr_priv);    /* calls list_del_rcu on hsr_priv */
-        restore_slaves(hsr_dev);
-        call_rcu(&hsr_priv->rcu_head, reclaim_hsr_dev);   /* reclaim hsr_priv */
+        del_timer_sync(&hsr->prune_timer);
+        del_timer_sync(&hsr->announce_timer);
+
+        synchronize_rcu();
+        free_netdev(hsr_dev);
 }
 
 static const struct net_device_ops hsr_device_ops = {
@@ -436,62 +374,51 @@ static const struct net_device_ops hsr_device_ops = {
         .ndo_open = hsr_dev_open,
         .ndo_stop = hsr_dev_close,
         .ndo_start_xmit = hsr_dev_xmit,
+        .ndo_fix_features = hsr_fix_features,
 };
 
+static struct device_type hsr_type = {
+        .name = "hsr",
+};
 
 void hsr_dev_setup(struct net_device *dev)
 {
         random_ether_addr(dev->dev_addr);
 
         ether_setup(dev);
-        dev->header_ops          = &hsr_header_ops;
-        dev->netdev_ops          = &hsr_device_ops;
-        dev->tx_queue_len        = 0;
+        dev->header_ops = &hsr_header_ops;
+        dev->netdev_ops = &hsr_device_ops;
+        SET_NETDEV_DEVTYPE(dev, &hsr_type);
+        dev->tx_queue_len = 0;
 
         dev->destructor = hsr_dev_destroy;
+
+        dev->hw_features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA |
+                           NETIF_F_GSO_MASK | NETIF_F_HW_CSUM |
+                           NETIF_F_HW_VLAN_CTAG_TX;
+
+        dev->features = dev->hw_features;
+
+        /* Prevent recursive tx locking */
+        dev->features |= NETIF_F_LLTX;
+        /* VLAN on top of HSR needs testing and probably some work on
+         * hsr_header_create() etc.
+         */
+        dev->features |= NETIF_F_VLAN_CHALLENGED;
+        /* Not sure about this. Taken from bridge code. netdev_features.h says
+         * it means "Does not change network namespaces".
+         */
+        dev->features |= NETIF_F_NETNS_LOCAL;
 }
 
 
 /* Return true if dev is a HSR master; return false otherwise.
  */
-bool is_hsr_master(struct net_device *dev)
+inline bool is_hsr_master(struct net_device *dev)
 {
         return (dev->netdev_ops->ndo_start_xmit == hsr_dev_xmit);
 }
 
-static int check_slave_ok(struct net_device *dev)
-{
-        /* Don't allow HSR on non-ethernet like devices */
-        if ((dev->flags & IFF_LOOPBACK) || (dev->type != ARPHRD_ETHER) ||
-            (dev->addr_len != ETH_ALEN)) {
-                netdev_info(dev, "Cannot use loopback or non-ethernet device as HSR slave.\n");
-                return -EINVAL;
-        }
-
-        /* Don't allow enslaving hsr devices */
-        if (is_hsr_master(dev)) {
-                netdev_info(dev, "Cannot create trees of HSR devices.\n");
-                return -EINVAL;
-        }
-
-        if (is_hsr_slave(dev)) {
-                netdev_info(dev, "This device is already a HSR slave.\n");
-                return -EINVAL;
-        }
-
-        if (dev->priv_flags & IFF_802_1Q_VLAN) {
-                netdev_info(dev, "HSR on top of VLAN is not yet supported in this driver.\n");
-                return -EINVAL;
-        }
-
-        /* HSR over bonded devices has not been tested, but I'm not sure it
-         * won't work...
-         */
-
-        return 0;
-}
-
-
 /* Default multicast address for HSR Supervision frames */
 static const unsigned char def_multicast_addr[ETH_ALEN] __aligned(2) = {
         0x01, 0x15, 0x4e, 0x00, 0x01, 0x00
@@ -500,97 +427,74 @@ static const unsigned char def_multicast_addr[ETH_ALEN] __aligned(2) = {
 int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2],
                      unsigned char multicast_spec)
 {
-        struct hsr_priv *hsr_priv;
-        int i;
+        struct hsr_priv *hsr;
+        struct hsr_port *port;
         int res;
 
-        hsr_priv = netdev_priv(hsr_dev);
-        hsr_priv->dev = hsr_dev;
-        INIT_LIST_HEAD(&hsr_priv->node_db);
-        INIT_LIST_HEAD(&hsr_priv->self_node_db);
-        for (i = 0; i < HSR_MAX_SLAVE; i++)
-                hsr_priv->slave[i] = slave[i];
-
-        spin_lock_init(&hsr_priv->seqnr_lock);
-        /* Overflow soon to find bugs easier: */
-        hsr_priv->sequence_nr = USHRT_MAX - 1024;
-
-        init_timer(&hsr_priv->announce_timer);
-        hsr_priv->announce_timer.function = hsr_announce;
-        hsr_priv->announce_timer.data = (unsigned long) hsr_priv;
+        hsr = netdev_priv(hsr_dev);
+        INIT_LIST_HEAD(&hsr->ports);
+        INIT_LIST_HEAD(&hsr->node_db);
+        INIT_LIST_HEAD(&hsr->self_node_db);
 
-        ether_addr_copy(hsr_priv->sup_multicast_addr, def_multicast_addr);
-        hsr_priv->sup_multicast_addr[ETH_ALEN - 1] = multicast_spec;
+        ether_addr_copy(hsr_dev->dev_addr, slave[0]->dev_addr);
 
-/* FIXME: should I modify the value of these?
- *
- * - hsr_dev->flags - i.e.
- *                      IFF_MASTER/SLAVE?
- * - hsr_dev->priv_flags - i.e.
- *                      IFF_EBRIDGE?
- *                      IFF_TX_SKB_SHARING?
- *                      IFF_HSR_MASTER/SLAVE?
- */
+        /* Make sure we recognize frames from ourselves in hsr_rcv() */
+        res = hsr_create_self_node(&hsr->self_node_db, hsr_dev->dev_addr,
+                                   slave[1]->dev_addr);
+        if (res < 0)
+                return res;
 
-        for (i = 0; i < HSR_MAX_SLAVE; i++) {
-                res = check_slave_ok(slave[i]);
-                if (res)
-                        return res;
-        }
+        spin_lock_init(&hsr->seqnr_lock);
+        /* Overflow soon to find bugs easier: */
+        hsr->sequence_nr = HSR_SEQNR_START;
 
-        hsr_dev->features = slave[0]->features & slave[1]->features;
-        /* Prevent recursive tx locking */
-        hsr_dev->features |= NETIF_F_LLTX;
-        /* VLAN on top of HSR needs testing and probably some work on
-         * hsr_header_create() etc.
-         */
-        hsr_dev->features |= NETIF_F_VLAN_CHALLENGED;
+        init_timer(&hsr->announce_timer);
+        hsr->announce_timer.function = hsr_announce;
+        hsr->announce_timer.data = (unsigned long) hsr;
 
-        /* Set hsr_dev's MAC address to that of mac_slave1 */
-        ether_addr_copy(hsr_dev->dev_addr, hsr_priv->slave[0]->dev_addr);
+        init_timer(&hsr->prune_timer);
+        hsr->prune_timer.function = hsr_prune_nodes;
+        hsr->prune_timer.data = (unsigned long) hsr;
 
-        /* Set required header length */
-        for (i = 0; i < HSR_MAX_SLAVE; i++) {
-                if (slave[i]->hard_header_len + HSR_TAGLEN >
-                                                hsr_dev->hard_header_len)
-                        hsr_dev->hard_header_len =
-                                        slave[i]->hard_header_len + HSR_TAGLEN;
-        }
+        ether_addr_copy(hsr->sup_multicast_addr, def_multicast_addr);
+        hsr->sup_multicast_addr[ETH_ALEN - 1] = multicast_spec;
 
-        /* MTU */
-        for (i = 0; i < HSR_MAX_SLAVE; i++)
-                if (slave[i]->mtu - HSR_TAGLEN < hsr_dev->mtu)
-                        hsr_dev->mtu = slave[i]->mtu - HSR_TAGLEN;
+        /* FIXME: should I modify the value of these?
+         *
+         * - hsr_dev->flags - i.e.
+         *                      IFF_MASTER/SLAVE?
+         * - hsr_dev->priv_flags - i.e.
+         *                      IFF_EBRIDGE?
+         *                      IFF_TX_SKB_SHARING?
+         *                      IFF_HSR_MASTER/SLAVE?
+         */
 
         /* Make sure the 1st call to netif_carrier_on() gets through */
         netif_carrier_off(hsr_dev);
 
-        /* Promiscuity */
-        for (i = 0; i < HSR_MAX_SLAVE; i++) {
-                res = dev_set_promiscuity(slave[i], 1);
-                if (res) {
-                        netdev_info(hsr_dev, "Cannot set slave promiscuity (%s, %d)\n",
-                                    slave[i]->name, res);
-                        goto fail;
-                }
-        }
+        res = hsr_add_port(hsr, hsr_dev, HSR_PT_MASTER);
+        if (res)
+                return res;
 
-        /* Make sure we recognize frames from ourselves in hsr_rcv() */
-        res = hsr_create_self_node(&hsr_priv->self_node_db,
-                                        hsr_dev->dev_addr,
-                                        hsr_priv->slave[1]->dev_addr);
-        if (res < 0)
+        res = register_netdevice(hsr_dev);
+        if (res)
                 goto fail;
 
-        res = register_netdevice(hsr_dev);
+        res = hsr_add_port(hsr, slave[0], HSR_PT_SLAVE_A);
+        if (res)
+                goto fail;
+        res = hsr_add_port(hsr, slave[1], HSR_PT_SLAVE_B);
         if (res)
                 goto fail;
 
-        register_hsr_master(hsr_priv);
+        hsr->prune_timer.expires = jiffies + msecs_to_jiffies(PRUNE_PERIOD);
+        add_timer(&hsr->prune_timer);
 
         return 0;
 
 fail:
-        restore_slaves(hsr_dev);
+        hsr_for_each_port(hsr, port)
+                hsr_del_port(port);
+
         return res;
 }