net/hsr: Better variable names and update of contact info.

Signed-off-by: Arvid Brodin <arvid.brodin@alten.se>
Signed-off-by: David S. Miller <davem@davemloft.net>

8 files changed, 304 insertions, 305 deletions

diff --git a/net/hsr/hsr_device.c b/net/hsr/hsr_device.c
index e5302b7f7ca9..4dc2a4207ee2 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.
@@ -71,49 +71,49 @@ void hsr_set_carrier(struct net_device *hsr_dev, struct net_device *slave1,
 
 void hsr_check_announce(struct net_device *hsr_dev, int 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)
+int hsr_get_max_mtu(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;
+        if (hsr->slave[0] && hsr->slave[1])
+                mtu_max = min(hsr->slave[0]->mtu, hsr->slave[1]->mtu);
+        else if (hsr->slave[0])
+                mtu_max = hsr->slave[0]->mtu;
+        else if (hsr->slave[1])
+                mtu_max = hsr->slave[1]->mtu;
         else
-                mtu_max = HSR_TAGLEN;
+                mtu_max = HSR_HLEN;
 
-        return mtu_max - HSR_TAGLEN;
+        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;
 
-        hsr_priv = netdev_priv(dev);
+        hsr = netdev_priv(dev);
 
-        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(hsr->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,19 +124,19 @@ 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;
+        struct hsr_priv *hsr;
         int i;
         char *slave_name;
 
-        hsr_priv = netdev_priv(dev);
+        hsr = netdev_priv(dev);
 
         for (i = 0; i < HSR_MAX_SLAVE; i++) {
-                if (hsr_priv->slave[i])
-                        slave_name = hsr_priv->slave[i]->name;
+                if (hsr->slave[i])
+                        slave_name = hsr->slave[i]->name;
                 else
                         slave_name = "null";
 
-                if (!is_slave_up(hsr_priv->slave[i]))
+                if (!is_slave_up(hsr->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);
         }
@@ -156,7 +156,7 @@ static int hsr_dev_close(struct net_device *dev)
 }
 
 
-static void hsr_fill_tag(struct hsr_ethhdr *hsr_ethhdr, struct hsr_priv *hsr_priv)
+static void hsr_fill_tag(struct hsr_ethhdr *hsr_ethhdr, struct hsr_priv *hsr)
 {
         unsigned long irqflags;
 
@@ -185,26 +185,26 @@ static void hsr_fill_tag(struct hsr_ethhdr *hsr_ethhdr, struct hsr_priv *hsr_pri
          */
         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);
+        spin_lock_irqsave(&hsr->seqnr_lock, irqflags);
+        hsr_ethhdr->hsr_tag.sequence_nr = htons(hsr->sequence_nr);
+        hsr->sequence_nr++;
+        spin_unlock_irqrestore(&hsr->seqnr_lock, irqflags);
 
         hsr_ethhdr->hsr_tag.encap_proto = hsr_ethhdr->ethhdr.h_proto;
 
         hsr_ethhdr->ethhdr.h_proto = htons(ETH_P_PRP);
 }
 
-static int slave_xmit(struct sk_buff *skb, struct hsr_priv *hsr_priv,
+static int slave_xmit(struct sk_buff *skb, struct hsr_priv *hsr,
                       enum hsr_dev_idx dev_idx)
 {
         struct hsr_ethhdr *hsr_ethhdr;
 
         hsr_ethhdr = (struct hsr_ethhdr *) skb->data;
 
-        skb->dev = hsr_priv->slave[dev_idx];
+        skb->dev = hsr->slave[dev_idx];
 
-        hsr_addr_subst_dest(hsr_priv, &hsr_ethhdr->ethhdr, dev_idx);
+        hsr_addr_subst_dest(hsr, &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.
@@ -217,36 +217,36 @@ static int slave_xmit(struct sk_buff *skb, struct hsr_priv *hsr_priv,
 
 static int hsr_dev_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
         struct hsr_ethhdr *hsr_ethhdr;
         struct sk_buff *skb2;
         int res1, res2;
 
-        hsr_priv = netdev_priv(dev);
+        hsr = 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);
+                hsr_fill_tag(hsr_ethhdr, hsr);
                 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);
+        if (likely(hsr->slave[HSR_DEV_SLAVE_A]))
+                res1 = slave_xmit(skb, hsr, HSR_DEV_SLAVE_A);
 
         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(skb2 && hsr->slave[HSR_DEV_SLAVE_B]))
+                res2 = slave_xmit(skb2, hsr, 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;
+                hsr->dev->stats.tx_packets++;
+                hsr->dev->stats.tx_bytes += skb->len;
         } else {
-                hsr_priv->dev->stats.tx_dropped++;
+                hsr->dev->stats.tx_dropped++;
         }
 
         return NETDEV_TX_OK;
@@ -262,21 +262,21 @@ static int hsr_header_create(struct sk_buff *skb, struct net_device *dev,
         /* 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)
+        if (skb_headroom(skb) < HSR_HLEN + ETH_HLEN)
                 return -ENOBUFS;
-        skb_push(skb, HSR_TAGLEN);
+        skb_push(skb, HSR_HLEN);
 
         /* To allow VLAN/HSR combos we should probably use
-         * res = dev_hard_header(skb, dev, type, daddr, saddr, len + HSR_TAGLEN);
+         * res = dev_hard_header(skb, dev, type, daddr, saddr, len + HSR_HLEN);
          * 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);
+        res = eth_header(skb, dev, type, daddr, saddr, len + HSR_HLEN);
         if (res <= 0)
                 return res;
         skb_reset_mac_header(skb);
 
-        return res + HSR_TAGLEN;
+        return res + HSR_HLEN;
 }
 
 
@@ -291,7 +291,7 @@ 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;
@@ -300,7 +300,7 @@ static int hsr_pad(int size)
 
 static void send_hsr_supervision_frame(struct net_device *hsr_dev, u8 type)
 {
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
         struct sk_buff *skb;
         int hlen, tlen;
         struct hsr_sup_tag *hsr_stag;
@@ -315,7 +315,7 @@ static void send_hsr_supervision_frame(struct net_device *hsr_dev, u8 type)
         if (skb == NULL)
                 return;
 
-        hsr_priv = netdev_priv(hsr_dev);
+        hsr = netdev_priv(hsr_dev);
 
         skb_reserve(skb, hlen);
 
@@ -324,7 +324,7 @@ static void send_hsr_supervision_frame(struct net_device *hsr_dev, u8 type)
         skb->priority = TC_PRIO_CONTROL;
 
         if (dev_hard_header(skb, skb->dev, ETH_P_PRP,
-                            hsr_priv->sup_multicast_addr,
+                            hsr->sup_multicast_addr,
                             skb->dev->dev_addr, skb->len) < 0)
                 goto out;
 
@@ -334,10 +334,10 @@ static void send_hsr_supervision_frame(struct net_device *hsr_dev, u8 type)
         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(&hsr->seqnr_lock, irqflags);
+        hsr_stag->sequence_nr = htons(hsr->sequence_nr);
+        hsr->sequence_nr++;
+        spin_unlock_irqrestore(&hsr->seqnr_lock, irqflags);
 
         hsr_stag->HSR_TLV_Type = type;
         hsr_stag->HSR_TLV_Length = 12;
@@ -360,48 +360,48 @@ out:
  */
 static void hsr_announce(unsigned long data)
 {
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
 
-        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++;
+        if (hsr->announce_count < 3) {
+                send_hsr_supervision_frame(hsr->dev, HSR_TLV_ANNOUNCE);
+                hsr->announce_count++;
         } else {
-                send_hsr_supervision_frame(hsr_priv->dev, HSR_TLV_LIFE_CHECK);
+                send_hsr_supervision_frame(hsr->dev, 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);
+        if (is_admin_up(hsr->dev))
+                add_timer(&hsr->announce_timer);
 }
 
 
 static void restore_slaves(struct net_device *hsr_dev)
 {
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
         int i;
         int res;
 
-        hsr_priv = netdev_priv(hsr_dev);
+        hsr = netdev_priv(hsr_dev);
 
         rtnl_lock();
 
         /* Restore promiscuity */
         for (i = 0; i < HSR_MAX_SLAVE; i++) {
-                if (!hsr_priv->slave[i])
+                if (!hsr->slave[i])
                         continue;
-                res = dev_set_promiscuity(hsr_priv->slave[i], -1);
+                res = dev_set_promiscuity(hsr->slave[i], -1);
                 if (res)
                         netdev_info(hsr_dev,
                                     "Cannot restore slave promiscuity (%s, %d)\n",
-                                    hsr_priv->slave[i]->name, res);
+                                    hsr->slave[i]->name, res);
         }
 
         rtnl_unlock();
@@ -409,10 +409,10 @@ static void restore_slaves(struct net_device *hsr_dev)
 
 static void reclaim_hsr_dev(struct rcu_head *rh)
 {
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
 
-        hsr_priv = container_of(rh, struct hsr_priv, rcu_head);
-        free_netdev(hsr_priv->dev);
+        hsr = container_of(rh, struct hsr_priv, rcu_head);
+        free_netdev(hsr->dev);
 }
 
 
@@ -421,14 +421,14 @@ 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;
 
-        hsr_priv = netdev_priv(hsr_dev);
+        hsr = netdev_priv(hsr_dev);
 
-        del_timer(&hsr_priv->announce_timer);
-        unregister_hsr_master(hsr_priv);    /* calls list_del_rcu on hsr_priv */
+        del_timer(&hsr->announce_timer);
+        unregister_hsr_master(hsr);    /* calls list_del_rcu on hsr */
         restore_slaves(hsr_dev);
-        call_rcu(&hsr_priv->rcu_head, reclaim_hsr_dev);   /* reclaim hsr_priv */
+        call_rcu(&hsr->rcu_head, reclaim_hsr_dev);   /* reclaim hsr */
 }
 
 static const struct net_device_ops hsr_device_ops = {
@@ -500,27 +500,27 @@ 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;
+        struct hsr_priv *hsr;
         int i;
         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);
+        hsr = netdev_priv(hsr_dev);
+        hsr->dev = hsr_dev;
+        INIT_LIST_HEAD(&hsr->node_db);
+        INIT_LIST_HEAD(&hsr->self_node_db);
         for (i = 0; i < HSR_MAX_SLAVE; i++)
-                hsr_priv->slave[i] = slave[i];
+                hsr->slave[i] = slave[i];
 
-        spin_lock_init(&hsr_priv->seqnr_lock);
+        spin_lock_init(&hsr->seqnr_lock);
         /* Overflow soon to find bugs easier: */
-        hsr_priv->sequence_nr = USHRT_MAX - 1024;
+        hsr->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;
+        init_timer(&hsr->announce_timer);
+        hsr->announce_timer.function = hsr_announce;
+        hsr->announce_timer.data = (unsigned long) hsr;
 
-        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->sup_multicast_addr, def_multicast_addr);
+        hsr->sup_multicast_addr[ETH_ALEN - 1] = multicast_spec;
 
 /* FIXME: should I modify the value of these?
  *
@@ -547,20 +547,20 @@ int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2],
         hsr_dev->features |= NETIF_F_VLAN_CHALLENGED;
 
         /* Set hsr_dev's MAC address to that of mac_slave1 */
-        ether_addr_copy(hsr_dev->dev_addr, hsr_priv->slave[0]->dev_addr);
+        ether_addr_copy(hsr_dev->dev_addr, hsr->slave[0]->dev_addr);
 
         /* Set required header length */
         for (i = 0; i < HSR_MAX_SLAVE; i++) {
-                if (slave[i]->hard_header_len + HSR_TAGLEN >
+                if (slave[i]->hard_header_len + HSR_HLEN >
                                                 hsr_dev->hard_header_len)
                         hsr_dev->hard_header_len =
-                                        slave[i]->hard_header_len + HSR_TAGLEN;
+                                        slave[i]->hard_header_len + HSR_HLEN;
         }
 
         /* 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;
+                if (slave[i]->mtu - HSR_HLEN < hsr_dev->mtu)
+                        hsr_dev->mtu = slave[i]->mtu - HSR_HLEN;
 
         /* Make sure the 1st call to netif_carrier_on() gets through */
         netif_carrier_off(hsr_dev);
@@ -576,9 +576,8 @@ int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2],
         }
 
         /* 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);
+        res = hsr_create_self_node(&hsr->self_node_db, hsr_dev->dev_addr,
+                                   hsr->slave[1]->dev_addr);
         if (res < 0)
                 goto fail;
 
@@ -586,7 +585,7 @@ int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2],
         if (res)
                 goto fail;
 
-        register_hsr_master(hsr_priv);
+        register_hsr_master(hsr);
 
         return 0;
 
diff --git a/net/hsr/hsr_device.h b/net/hsr/hsr_device.h
index 2c7148e73914..feb744f90f3d 100644
--- a/net/hsr/hsr_device.h
+++ b/net/hsr/hsr_device.h
@@ -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
  */
 
 #ifndef __HSR_DEVICE_H
@@ -24,6 +24,6 @@ void hsr_set_carrier(struct net_device *hsr_dev, struct net_device *slave1,
                      struct net_device *slave2);
 void hsr_check_announce(struct net_device *hsr_dev, int old_operstate);
 bool is_hsr_master(struct net_device *dev);
-int hsr_get_max_mtu(struct hsr_priv *hsr_priv);
+int hsr_get_max_mtu(struct hsr_priv *hsr);
 
 #endif /* __HSR_DEVICE_H */
diff --git a/net/hsr/hsr_framereg.c b/net/hsr/hsr_framereg.c
index 83e58449366a..b419edbd7012 100644
--- a/net/hsr/hsr_framereg.c
+++ b/net/hsr/hsr_framereg.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
  *
  * The HSR spec says never to forward the same frame twice on the same
  * interface. A frame is identified by its source MAC address and its HSR
@@ -23,17 +23,17 @@
 #include "hsr_netlink.h"
 
 
-struct node_entry {
-        struct list_head mac_list;
-        unsigned char   MacAddressA[ETH_ALEN];
-        unsigned char   MacAddressB[ETH_ALEN];
-        enum hsr_dev_idx   AddrB_if;    /* The local slave through which AddrB
-                                         * frames are received from this node
-                                         */
-        unsigned long   time_in[HSR_MAX_SLAVE];
-        bool            time_in_stale[HSR_MAX_SLAVE];
-        u16             seq_out[HSR_MAX_DEV];
-        struct rcu_head rcu_head;
+struct hsr_node {
+        struct list_head        mac_list;
+        unsigned char           MacAddressA[ETH_ALEN];
+        unsigned char           MacAddressB[ETH_ALEN];
+        enum hsr_dev_idx        AddrB_if;/* The local slave through which AddrB
+                                          * frames are received from this node
+                                          */
+        unsigned long           time_in[HSR_MAX_SLAVE];
+        bool                    time_in_stale[HSR_MAX_SLAVE];
+        u16                     seq_out[HSR_MAX_DEV];
+        struct rcu_head         rcu_head;
 };
 
 /*      TODO: use hash lists for mac addresses (linux/jhash.h)?    */
@@ -42,10 +42,10 @@ struct node_entry {
 
 /* Search for mac entry. Caller must hold rcu read lock.
  */
-static struct node_entry *find_node_by_AddrA(struct list_head *node_db,
-                                             const unsigned char addr[ETH_ALEN])
+static struct hsr_node *find_node_by_AddrA(struct list_head *node_db,
+                                           const unsigned char addr[ETH_ALEN])
 {
-        struct node_entry *node;
+        struct hsr_node *node;
 
         list_for_each_entry_rcu(node, node_db, mac_list) {
                 if (ether_addr_equal(node->MacAddressA, addr))
@@ -58,10 +58,10 @@ static struct node_entry *find_node_by_AddrA(struct list_head *node_db,
 
 /* Search for mac entry. Caller must hold rcu read lock.
  */
-static struct node_entry *find_node_by_AddrB(struct list_head *node_db,
-                                             const unsigned char addr[ETH_ALEN])
+static struct hsr_node *find_node_by_AddrB(struct list_head *node_db,
+                                           const unsigned char addr[ETH_ALEN])
 {
-        struct node_entry *node;
+        struct hsr_node *node;
 
         list_for_each_entry_rcu(node, node_db, mac_list) {
                 if (ether_addr_equal(node->MacAddressB, addr))
@@ -74,9 +74,9 @@ static struct node_entry *find_node_by_AddrB(struct list_head *node_db,
 
 /* Search for mac entry. Caller must hold rcu read lock.
  */
-struct node_entry *hsr_find_node(struct list_head *node_db, struct sk_buff *skb)
+struct hsr_node *hsr_find_node(struct list_head *node_db, struct sk_buff *skb)
 {
-        struct node_entry *node;
+        struct hsr_node *node;
         struct ethhdr *ethhdr;
 
         if (!skb_mac_header_was_set(skb))
@@ -102,7 +102,7 @@ int hsr_create_self_node(struct list_head *self_node_db,
                          unsigned char addr_a[ETH_ALEN],
                          unsigned char addr_b[ETH_ALEN])
 {
-        struct node_entry *node, *oldnode;
+        struct hsr_node *node, *oldnode;
 
         node = kmalloc(sizeof(*node), GFP_KERNEL);
         if (!node)
@@ -113,7 +113,7 @@ int hsr_create_self_node(struct list_head *self_node_db,
 
         rcu_read_lock();
         oldnode = list_first_or_null_rcu(self_node_db,
-                                                struct node_entry, mac_list);
+                                                struct hsr_node, mac_list);
         if (oldnode) {
                 list_replace_rcu(&oldnode->mac_list, &node->mac_list);
                 rcu_read_unlock();
@@ -154,10 +154,10 @@ int hsr_create_self_node(struct list_head *self_node_db,
  * We also need to detect if the sender's SlaveA and SlaveB cables have been
  * swapped.
  */
-struct node_entry *hsr_merge_node(struct hsr_priv *hsr_priv,
-                                  struct node_entry *node,
-                                  struct sk_buff *skb,
-                                  enum hsr_dev_idx dev_idx)
+struct hsr_node *hsr_merge_node(struct hsr_priv *hsr,
+                                struct hsr_node *node,
+                                struct sk_buff *skb,
+                                enum hsr_dev_idx dev_idx)
 {
         struct hsr_sup_payload *hsr_sp;
         struct hsr_ethhdr_sp *hsr_ethsup;
@@ -194,7 +194,7 @@ struct node_entry *hsr_merge_node(struct hsr_priv *hsr_priv,
         if (node)
                 return node;
 
-        node = find_node_by_AddrA(&hsr_priv->node_db, hsr_sp->MacAddressA);
+        node = find_node_by_AddrA(&hsr->node_db, hsr_sp->MacAddressA);
         if (node) {
                 /* Node is known, but frame was received from an unknown
                  * address. Node is PICS_SUBS capable; merge its AddrB.
@@ -224,7 +224,7 @@ struct node_entry *hsr_merge_node(struct hsr_priv *hsr_priv,
         for (i = 0; i < HSR_MAX_DEV; i++)
                 node->seq_out[i] = ntohs(hsr_ethsup->hsr_sup.sequence_nr) - 1;
 
-        list_add_tail_rcu(&node->mac_list, &hsr_priv->node_db);
+        list_add_tail_rcu(&node->mac_list, &hsr->node_db);
 
         return node;
 }
@@ -236,10 +236,10 @@ struct node_entry *hsr_merge_node(struct hsr_priv *hsr_priv,
  * address with that node's "official" address (MacAddressA) so that upper
  * layers recognize where it came from.
  */
-void hsr_addr_subst_source(struct hsr_priv *hsr_priv, struct sk_buff *skb)
+void hsr_addr_subst_source(struct hsr_priv *hsr, struct sk_buff *skb)
 {
         struct ethhdr *ethhdr;
-        struct node_entry *node;
+        struct hsr_node *node;
 
         if (!skb_mac_header_was_set(skb)) {
                 WARN_ONCE(1, "%s: Mac header not set\n", __func__);
@@ -248,7 +248,7 @@ void hsr_addr_subst_source(struct hsr_priv *hsr_priv, struct sk_buff *skb)
         ethhdr = (struct ethhdr *) skb_mac_header(skb);
 
         rcu_read_lock();
-        node = find_node_by_AddrB(&hsr_priv->node_db, ethhdr->h_source);
+        node = find_node_by_AddrB(&hsr->node_db, ethhdr->h_source);
         if (node)
                 ether_addr_copy(ethhdr->h_source, node->MacAddressA);
         rcu_read_unlock();
@@ -264,13 +264,13 @@ void hsr_addr_subst_source(struct hsr_priv *hsr_priv, struct sk_buff *skb)
  * This is needed to keep the packets flowing through switches that learn on
  * which "side" the different interfaces are.
  */
-void hsr_addr_subst_dest(struct hsr_priv *hsr_priv, struct ethhdr *ethhdr,
+void hsr_addr_subst_dest(struct hsr_priv *hsr, struct ethhdr *ethhdr,
                          enum hsr_dev_idx dev_idx)
 {
-        struct node_entry *node;
+        struct hsr_node *node;
 
         rcu_read_lock();
-        node = find_node_by_AddrA(&hsr_priv->node_db, ethhdr->h_dest);
+        node = find_node_by_AddrA(&hsr->node_db, ethhdr->h_dest);
         if (node && (node->AddrB_if == dev_idx))
                 ether_addr_copy(ethhdr->h_dest, node->MacAddressB);
         rcu_read_unlock();
@@ -295,7 +295,7 @@ static bool seq_nr_after(u16 a, u16 b)
 #define seq_nr_before_or_eq(a, b)       (!seq_nr_after((a), (b)))
 
 
-void hsr_register_frame_in(struct node_entry *node, enum hsr_dev_idx dev_idx)
+void hsr_register_frame_in(struct hsr_node *node, enum hsr_dev_idx dev_idx)
 {
         if ((dev_idx < 0) || (dev_idx >= HSR_MAX_SLAVE)) {
                 WARN_ONCE(1, "%s: Invalid dev_idx (%d)\n", __func__, dev_idx);
@@ -314,7 +314,7 @@ void hsr_register_frame_in(struct node_entry *node, enum hsr_dev_idx dev_idx)
  *       0 otherwise, or
  *       negative error code on error
  */
-int hsr_register_frame_out(struct node_entry *node, enum hsr_dev_idx dev_idx,
+int hsr_register_frame_out(struct hsr_node *node, enum hsr_dev_idx dev_idx,
                            struct sk_buff *skb)
 {
         struct hsr_ethhdr *hsr_ethhdr;
@@ -340,7 +340,7 @@ int hsr_register_frame_out(struct node_entry *node, enum hsr_dev_idx dev_idx,
 
 
 
-static bool is_late(struct node_entry *node, enum hsr_dev_idx dev_idx)
+static bool is_late(struct hsr_node *node, enum hsr_dev_idx dev_idx)
 {
         enum hsr_dev_idx other;
 
@@ -366,14 +366,14 @@ static bool is_late(struct node_entry *node, enum hsr_dev_idx dev_idx)
 /* Remove stale sequence_nr records. Called by timer every
  * HSR_LIFE_CHECK_INTERVAL (two seconds or so).
  */
-void hsr_prune_nodes(struct hsr_priv *hsr_priv)
+void hsr_prune_nodes(struct hsr_priv *hsr)
 {
-        struct node_entry *node;
+        struct hsr_node *node;
         unsigned long timestamp;
         unsigned long time_a, time_b;
 
         rcu_read_lock();
-        list_for_each_entry_rcu(node, &hsr_priv->node_db, mac_list) {
+        list_for_each_entry_rcu(node, &hsr->node_db, mac_list) {
                 /* Shorthand */
                 time_a = node->time_in[HSR_DEV_SLAVE_A];
                 time_b = node->time_in[HSR_DEV_SLAVE_B];
@@ -399,17 +399,17 @@ void hsr_prune_nodes(struct hsr_priv *hsr_priv)
                                         msecs_to_jiffies(1.5*MAX_SLAVE_DIFF))) {
 
                         if (is_late(node, HSR_DEV_SLAVE_A))
-                                hsr_nl_ringerror(hsr_priv, node->MacAddressA,
+                                hsr_nl_ringerror(hsr, node->MacAddressA,
                                                  HSR_DEV_SLAVE_A);
                         else if (is_late(node, HSR_DEV_SLAVE_B))
-                                hsr_nl_ringerror(hsr_priv, node->MacAddressA,
+                                hsr_nl_ringerror(hsr, node->MacAddressA,
                                                  HSR_DEV_SLAVE_B);
                 }
 
                 /* Prune old entries */
                 if (time_is_before_jiffies(timestamp +
                                         msecs_to_jiffies(HSR_NODE_FORGET_TIME))) {
-                        hsr_nl_nodedown(hsr_priv, node->MacAddressA);
+                        hsr_nl_nodedown(hsr, node->MacAddressA);
                         list_del_rcu(&node->mac_list);
                         /* Note that we need to free this entry later: */
                         kfree_rcu(node, rcu_head);
@@ -419,21 +419,21 @@ void hsr_prune_nodes(struct hsr_priv *hsr_priv)
 }
 
 
-void *hsr_get_next_node(struct hsr_priv *hsr_priv, void *_pos,
+void *hsr_get_next_node(struct hsr_priv *hsr, void *_pos,
                         unsigned char addr[ETH_ALEN])
 {
-        struct node_entry *node;
+        struct hsr_node *node;
 
         if (!_pos) {
-                node = list_first_or_null_rcu(&hsr_priv->node_db,
-                                                struct node_entry, mac_list);
+                node = list_first_or_null_rcu(&hsr->node_db,
+                                              struct hsr_node, mac_list);
                 if (node)
                         ether_addr_copy(addr, node->MacAddressA);
                 return node;
         }
 
         node = _pos;
-        list_for_each_entry_continue_rcu(node, &hsr_priv->node_db, mac_list) {
+        list_for_each_entry_continue_rcu(node, &hsr->node_db, mac_list) {
                 ether_addr_copy(addr, node->MacAddressA);
                 return node;
         }
@@ -442,7 +442,7 @@ void *hsr_get_next_node(struct hsr_priv *hsr_priv, void *_pos,
 }
 
 
-int hsr_get_node_data(struct hsr_priv *hsr_priv,
+int hsr_get_node_data(struct hsr_priv *hsr,
                       const unsigned char *addr,
                       unsigned char addr_b[ETH_ALEN],
                       unsigned int *addr_b_ifindex,
@@ -451,12 +451,12 @@ int hsr_get_node_data(struct hsr_priv *hsr_priv,
                       int *if2_age,
                       u16 *if2_seq)
 {
-        struct node_entry *node;
+        struct hsr_node *node;
         unsigned long tdiff;
 
 
         rcu_read_lock();
-        node = find_node_by_AddrA(&hsr_priv->node_db, addr);
+        node = find_node_by_AddrA(&hsr->node_db, addr);
         if (!node) {
                 rcu_read_unlock();
                 return -ENOENT; /* No such entry */
@@ -488,8 +488,8 @@ int hsr_get_node_data(struct hsr_priv *hsr_priv,
         *if1_seq = node->seq_out[HSR_DEV_SLAVE_B];
         *if2_seq = node->seq_out[HSR_DEV_SLAVE_A];
 
-        if ((node->AddrB_if != HSR_DEV_NONE) && hsr_priv->slave[node->AddrB_if])
-                *addr_b_ifindex = hsr_priv->slave[node->AddrB_if]->ifindex;
+        if ((node->AddrB_if != HSR_DEV_NONE) && hsr->slave[node->AddrB_if])
+                *addr_b_ifindex = hsr->slave[node->AddrB_if]->ifindex;
         else
                 *addr_b_ifindex = -1;
 
diff --git a/net/hsr/hsr_framereg.h b/net/hsr/hsr_framereg.h
index e6c4022030ad..3675139df379 100644
--- a/net/hsr/hsr_framereg.h
+++ b/net/hsr/hsr_framereg.h
@@ -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,42 +6,42 @@
  * any later version.
  *
  * Author(s):
- *      2011-2013 Arvid Brodin, arvid.brodin@xdin.com
+ *      2011-2014 Arvid Brodin, arvid.brodin@alten.se
  */
 
-#ifndef _HSR_FRAMEREG_H
-#define _HSR_FRAMEREG_H
+#ifndef __HSR_FRAMEREG_H
+#define __HSR_FRAMEREG_H
 
 #include "hsr_main.h"
 
-struct node_entry;
+struct hsr_node;
 
-struct node_entry *hsr_find_node(struct list_head *node_db, struct sk_buff *skb);
+struct hsr_node *hsr_find_node(struct list_head *node_db, struct sk_buff *skb);
 
-struct node_entry *hsr_merge_node(struct hsr_priv *hsr_priv,
-                                  struct node_entry *node,
-                                  struct sk_buff *skb,
-                                  enum hsr_dev_idx dev_idx);
+struct hsr_node *hsr_merge_node(struct hsr_priv *hsr,
+                                struct hsr_node *node,
+                                struct sk_buff *skb,
+                                enum hsr_dev_idx dev_idx);
 
-void hsr_addr_subst_source(struct hsr_priv *hsr_priv, struct sk_buff *skb);
-void hsr_addr_subst_dest(struct hsr_priv *hsr_priv, struct ethhdr *ethhdr,
+void hsr_addr_subst_source(struct hsr_priv *hsr, struct sk_buff *skb);
+void hsr_addr_subst_dest(struct hsr_priv *hsr, struct ethhdr *ethhdr,
                          enum hsr_dev_idx dev_idx);
 
-void hsr_register_frame_in(struct node_entry *node, enum hsr_dev_idx dev_idx);
+void hsr_register_frame_in(struct hsr_node *node, enum hsr_dev_idx dev_idx);
 
-int hsr_register_frame_out(struct node_entry *node, enum hsr_dev_idx dev_idx,
+int hsr_register_frame_out(struct hsr_node *node, enum hsr_dev_idx dev_idx,
                            struct sk_buff *skb);
 
-void hsr_prune_nodes(struct hsr_priv *hsr_priv);
+void hsr_prune_nodes(struct hsr_priv *hsr);
 
 int hsr_create_self_node(struct list_head *self_node_db,
                          unsigned char addr_a[ETH_ALEN],
                          unsigned char addr_b[ETH_ALEN]);
 
-void *hsr_get_next_node(struct hsr_priv *hsr_priv, void *_pos,
+void *hsr_get_next_node(struct hsr_priv *hsr, void *_pos,
                         unsigned char addr[ETH_ALEN]);
 
-int hsr_get_node_data(struct hsr_priv *hsr_priv,
+int hsr_get_node_data(struct hsr_priv *hsr,
                       const unsigned char *addr,
                       unsigned char addr_b[ETH_ALEN],
                       unsigned int *addr_b_ifindex,
@@ -50,4 +50,4 @@ int hsr_get_node_data(struct hsr_priv *hsr_priv,
                       int *if2_age,
                       u16 *if2_seq);
 
-#endif /* _HSR_FRAMEREG_H */
+#endif /* __HSR_FRAMEREG_H */
diff --git a/net/hsr/hsr_main.c b/net/hsr/hsr_main.c
index 3fee5218a691..99b8fc4eca6c 100644
--- a/net/hsr/hsr_main.c
+++ b/net/hsr/hsr_main.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
  *
  * In addition to routines for registering and unregistering HSR support, this
  * file also contains the receive routine that handles all incoming frames with
@@ -26,30 +26,30 @@
 /* List of all registered virtual HSR devices */
 static LIST_HEAD(hsr_list);
 
-void register_hsr_master(struct hsr_priv *hsr_priv)
+void register_hsr_master(struct hsr_priv *hsr)
 {
-        list_add_tail_rcu(&hsr_priv->hsr_list, &hsr_list);
+        list_add_tail_rcu(&hsr->hsr_list, &hsr_list);
 }
 
-void unregister_hsr_master(struct hsr_priv *hsr_priv)
+void unregister_hsr_master(struct hsr_priv *hsr)
 {
-        struct hsr_priv *hsr_priv_it;
+        struct hsr_priv *hsr_it;
 
-        list_for_each_entry(hsr_priv_it, &hsr_list, hsr_list)
-                if (hsr_priv_it == hsr_priv) {
-                        list_del_rcu(&hsr_priv_it->hsr_list);
+        list_for_each_entry(hsr_it, &hsr_list, hsr_list)
+                if (hsr_it == hsr) {
+                        list_del_rcu(&hsr_it->hsr_list);
                         return;
                 }
 }
 
 bool is_hsr_slave(struct net_device *dev)
 {
-        struct hsr_priv *hsr_priv_it;
+        struct hsr_priv *hsr_it;
 
-        list_for_each_entry_rcu(hsr_priv_it, &hsr_list, hsr_list) {
-                if (dev == hsr_priv_it->slave[0])
+        list_for_each_entry_rcu(hsr_it, &hsr_list, hsr_list) {
+                if (dev == hsr_it->slave[0])
                         return true;
-                if (dev == hsr_priv_it->slave[1])
+                if (dev == hsr_it->slave[1])
                         return true;
         }
 
@@ -62,14 +62,14 @@ bool is_hsr_slave(struct net_device *dev)
  */
 static struct hsr_priv *get_hsr_master(struct net_device *dev)
 {
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
 
         rcu_read_lock();
-        list_for_each_entry_rcu(hsr_priv, &hsr_list, hsr_list)
-                if ((dev == hsr_priv->slave[0]) ||
-                    (dev == hsr_priv->slave[1])) {
+        list_for_each_entry_rcu(hsr, &hsr_list, hsr_list)
+                if ((dev == hsr->slave[0]) ||
+                    (dev == hsr->slave[1])) {
                         rcu_read_unlock();
-                        return hsr_priv;
+                        return hsr;
                 }
 
         rcu_read_unlock();
@@ -80,13 +80,13 @@ static struct hsr_priv *get_hsr_master(struct net_device *dev)
 /* If dev is a HSR slave device, return the other slave device. Return NULL
  * otherwise.
  */
-static struct net_device *get_other_slave(struct hsr_priv *hsr_priv,
+static struct net_device *get_other_slave(struct hsr_priv *hsr,
                                           struct net_device *dev)
 {
-        if (dev == hsr_priv->slave[0])
-                return hsr_priv->slave[1];
-        if (dev == hsr_priv->slave[1])
-                return hsr_priv->slave[0];
+        if (dev == hsr->slave[0])
+                return hsr->slave[1];
+        if (dev == hsr->slave[1])
+                return hsr->slave[0];
 
         return NULL;
 }
@@ -96,7 +96,7 @@ static int hsr_netdev_notify(struct notifier_block *nb, unsigned long event,
                              void *ptr)
 {
         struct net_device *slave, *other_slave;
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
         int old_operstate;
         int mtu_max;
         int res;
@@ -104,68 +104,68 @@ static int hsr_netdev_notify(struct notifier_block *nb, unsigned long event,
 
         dev = netdev_notifier_info_to_dev(ptr);
 
-        hsr_priv = get_hsr_master(dev);
-        if (hsr_priv) {
+        hsr = get_hsr_master(dev);
+        if (hsr) {
                 /* dev is a slave device */
                 slave = dev;
-                other_slave = get_other_slave(hsr_priv, slave);
+                other_slave = get_other_slave(hsr, slave);
         } else {
                 if (!is_hsr_master(dev))
                         return NOTIFY_DONE;
-                hsr_priv = netdev_priv(dev);
-                slave = hsr_priv->slave[0];
-                other_slave = hsr_priv->slave[1];
+                hsr = netdev_priv(dev);
+                slave = hsr->slave[0];
+                other_slave = hsr->slave[1];
         }
 
         switch (event) {
         case NETDEV_UP:         /* Administrative state DOWN */
         case NETDEV_DOWN:       /* Administrative state UP */
         case NETDEV_CHANGE:     /* Link (carrier) state changes */
-                old_operstate = hsr_priv->dev->operstate;
-                hsr_set_carrier(hsr_priv->dev, slave, other_slave);
+                old_operstate = hsr->dev->operstate;
+                hsr_set_carrier(hsr->dev, slave, other_slave);
                 /* netif_stacked_transfer_operstate() cannot be used here since
                  * it doesn't set IF_OPER_LOWERLAYERDOWN (?)
                  */
-                hsr_set_operstate(hsr_priv->dev, slave, other_slave);
-                hsr_check_announce(hsr_priv->dev, old_operstate);
+                hsr_set_operstate(hsr->dev, slave, other_slave);
+                hsr_check_announce(hsr->dev, old_operstate);
                 break;
         case NETDEV_CHANGEADDR:
 
                 /* This should not happen since there's no ndo_set_mac_address()
                  * for HSR devices - i.e. not supported.
                  */
-                if (dev == hsr_priv->dev)
+                if (dev == hsr->dev)
                         break;
 
-                if (dev == hsr_priv->slave[0])
-                        ether_addr_copy(hsr_priv->dev->dev_addr,
-                                        hsr_priv->slave[0]->dev_addr);
+                if (dev == hsr->slave[0])
+                        ether_addr_copy(hsr->dev->dev_addr,
+                                        hsr->slave[0]->dev_addr);
 
                 /* Make sure we recognize frames from ourselves in hsr_rcv() */
-                res = hsr_create_self_node(&hsr_priv->self_node_db,
-                                           hsr_priv->dev->dev_addr,
-                                           hsr_priv->slave[1] ?
-                                                hsr_priv->slave[1]->dev_addr :
-                                                hsr_priv->dev->dev_addr);
+                res = hsr_create_self_node(&hsr->self_node_db,
+                                           hsr->dev->dev_addr,
+                                           hsr->slave[1] ?
+                                                hsr->slave[1]->dev_addr :
+                                                hsr->dev->dev_addr);
                 if (res)
-                        netdev_warn(hsr_priv->dev,
+                        netdev_warn(hsr->dev,
                                     "Could not update HSR node address.\n");
 
-                if (dev == hsr_priv->slave[0])
-                        call_netdevice_notifiers(NETDEV_CHANGEADDR, hsr_priv->dev);
+                if (dev == hsr->slave[0])
+                        call_netdevice_notifiers(NETDEV_CHANGEADDR, hsr->dev);
                 break;
         case NETDEV_CHANGEMTU:
-                if (dev == hsr_priv->dev)
+                if (dev == hsr->dev)
                         break; /* Handled in ndo_change_mtu() */
-                mtu_max = hsr_get_max_mtu(hsr_priv);
-                if (hsr_priv->dev->mtu > mtu_max)
-                        dev_set_mtu(hsr_priv->dev, mtu_max);
+                mtu_max = hsr_get_max_mtu(hsr);
+                if (hsr->dev->mtu > mtu_max)
+                        dev_set_mtu(hsr->dev, mtu_max);
                 break;
         case NETDEV_UNREGISTER:
-                if (dev == hsr_priv->slave[0])
-                        hsr_priv->slave[0] = NULL;
-                if (dev == hsr_priv->slave[1])
-                        hsr_priv->slave[1] = NULL;
+                if (dev == hsr->slave[0])
+                        hsr->slave[0] = NULL;
+                if (dev == hsr->slave[1])
+                        hsr->slave[1] = NULL;
 
                 /* There should really be a way to set a new slave device... */
 
@@ -185,11 +185,11 @@ static struct timer_list prune_timer;
 
 static void prune_nodes_all(unsigned long data)
 {
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
 
         rcu_read_lock();
-        list_for_each_entry_rcu(hsr_priv, &hsr_list, hsr_list)
-                hsr_prune_nodes(hsr_priv);
+        list_for_each_entry_rcu(hsr, &hsr_list, hsr_list)
+                hsr_prune_nodes(hsr);
         rcu_read_unlock();
 
         prune_timer.expires = jiffies + msecs_to_jiffies(PRUNE_PERIOD);
@@ -207,12 +207,12 @@ static struct sk_buff *hsr_pull_tag(struct sk_buff *skb)
                 goto err_free;
         skb = skb2;
 
-        if (unlikely(!pskb_may_pull(skb, HSR_TAGLEN)))
+        if (unlikely(!pskb_may_pull(skb, HSR_HLEN)))
                 goto err_free;
 
         hsr_tag = (struct hsr_tag *) skb->data;
         skb->protocol = hsr_tag->encap_proto;
-        skb_pull(skb, HSR_TAGLEN);
+        skb_pull(skb, HSR_HLEN);
 
         return skb;
 
@@ -237,12 +237,12 @@ err_free:
  * 3) Allow different MAC addresses for the two slave interfaces, using the
  *    MacAddressA field.
  */
-static bool is_supervision_frame(struct hsr_priv *hsr_priv, struct sk_buff *skb)
+static bool is_supervision_frame(struct hsr_priv *hsr, struct sk_buff *skb)
 {
         struct hsr_sup_tag *hsr_stag;
 
         if (!ether_addr_equal(eth_hdr(skb)->h_dest,
-                              hsr_priv->sup_multicast_addr))
+                              hsr->sup_multicast_addr))
                 return false;
 
         hsr_stag = (struct hsr_sup_tag *) skb->data;
@@ -263,25 +263,25 @@ static bool is_supervision_frame(struct hsr_priv *hsr_priv, struct sk_buff *skb)
 static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
                    struct packet_type *pt, struct net_device *orig_dev)
 {
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
         struct net_device *other_slave;
-        struct node_entry *node;
+        struct hsr_node *node;
         bool deliver_to_self;
         struct sk_buff *skb_deliver;
         enum hsr_dev_idx dev_in_idx, dev_other_idx;
         bool dup_out;
         int ret;
 
-        hsr_priv = get_hsr_master(dev);
+        hsr = get_hsr_master(dev);
 
-        if (!hsr_priv) {
+        if (!hsr) {
                 /* Non-HSR-slave device 'dev' is connected to a HSR network */
                 kfree_skb(skb);
                 dev->stats.rx_errors++;
                 return NET_RX_SUCCESS;
         }
 
-        if (dev == hsr_priv->slave[0]) {
+        if (dev == hsr->slave[0]) {
                 dev_in_idx = HSR_DEV_SLAVE_A;
                 dev_other_idx = HSR_DEV_SLAVE_B;
         } else {
@@ -289,7 +289,7 @@ static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
                 dev_other_idx = HSR_DEV_SLAVE_A;
         }
 
-        node = hsr_find_node(&hsr_priv->self_node_db, skb);
+        node = hsr_find_node(&hsr->self_node_db, skb);
         if (node) {
                 /* Always kill frames sent by ourselves */
                 kfree_skb(skb);
@@ -303,22 +303,22 @@ static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
             (skb->pkt_type == PACKET_BROADCAST))
                 deliver_to_self = true;
         else if (ether_addr_equal(eth_hdr(skb)->h_dest,
-                                     hsr_priv->dev->dev_addr)) {
+                                     hsr->dev->dev_addr)) {
                 skb->pkt_type = PACKET_HOST;
                 deliver_to_self = true;
         }
 
 
         rcu_read_lock(); /* node_db */
-        node = hsr_find_node(&hsr_priv->node_db, skb);
+        node = hsr_find_node(&hsr->node_db, skb);
 
-        if (is_supervision_frame(hsr_priv, skb)) {
+        if (is_supervision_frame(hsr, skb)) {
                 skb_pull(skb, sizeof(struct hsr_sup_tag));
-                node = hsr_merge_node(hsr_priv, node, skb, dev_in_idx);
+                node = hsr_merge_node(hsr, node, skb, dev_in_idx);
                 if (!node) {
                         rcu_read_unlock(); /* node_db */
                         kfree_skb(skb);
-                        hsr_priv->dev->stats.rx_dropped++;
+                        hsr->dev->stats.rx_dropped++;
                         return NET_RX_DROP;
                 }
                 skb_push(skb, sizeof(struct hsr_sup_tag));
@@ -345,7 +345,7 @@ static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
 
         /* Forward this frame? */
         if (!dup_out && (skb->pkt_type != PACKET_HOST))
-                other_slave = get_other_slave(hsr_priv, dev);
+                other_slave = get_other_slave(hsr, dev);
         else
                 other_slave = NULL;
 
@@ -368,7 +368,7 @@ static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
                 skb_deliver = pskb_copy(skb, GFP_ATOMIC);
                 if (!skb_deliver) {
                         deliver_to_self = false;
-                        hsr_priv->dev->stats.rx_dropped++;
+                        hsr->dev->stats.rx_dropped++;
                 }
         }
 
@@ -377,7 +377,7 @@ static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
 
                 skb_deliver = hsr_pull_tag(skb_deliver);
                 if (!skb_deliver) {
-                        hsr_priv->dev->stats.rx_dropped++;
+                        hsr->dev->stats.rx_dropped++;
                         goto forward;
                 }
 #if !defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
@@ -386,7 +386,7 @@ static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
                  * tag. In practice, this removes/overwrites the HSR tag in
                  * the header and restores a "standard" packet.
                  */
-                memmove(skb_deliver->data - HSR_TAGLEN, skb_deliver->data,
+                memmove(skb_deliver->data - HSR_HLEN, skb_deliver->data,
                         skb_headlen(skb_deliver));
 
                 /* Adjust skb members so they correspond with the move above.
@@ -397,20 +397,20 @@ static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
                  * the mac header nor the head. So we only need to adjust data
                  * and tail:
                  */
-                skb_deliver->data -= HSR_TAGLEN;
-                skb_deliver->tail -= HSR_TAGLEN;
+                skb_deliver->data -= HSR_HLEN;
+                skb_deliver->tail -= HSR_HLEN;
 #endif
-                skb_deliver->dev = hsr_priv->dev;
-                hsr_addr_subst_source(hsr_priv, skb_deliver);
+                skb_deliver->dev = hsr->dev;
+                hsr_addr_subst_source(hsr, skb_deliver);
                 multicast_frame = (skb_deliver->pkt_type == PACKET_MULTICAST);
                 ret = netif_rx(skb_deliver);
                 if (ret == NET_RX_DROP) {
-                        hsr_priv->dev->stats.rx_dropped++;
+                        hsr->dev->stats.rx_dropped++;
                 } else {
-                        hsr_priv->dev->stats.rx_packets++;
-                        hsr_priv->dev->stats.rx_bytes += skb->len;
+                        hsr->dev->stats.rx_packets++;
+                        hsr->dev->stats.rx_bytes += skb->len;
                         if (multicast_frame)
-                                hsr_priv->dev->stats.multicast++;
+                                hsr->dev->stats.multicast++;
                 }
         }
 
@@ -439,7 +439,7 @@ static int __init hsr_init(void)
 {
         int res;
 
-        BUILD_BUG_ON(sizeof(struct hsr_tag) != HSR_TAGLEN);
+        BUILD_BUG_ON(sizeof(struct hsr_tag) != HSR_HLEN);
 
         dev_add_pack(&hsr_pt);
 
diff --git a/net/hsr/hsr_main.h b/net/hsr/hsr_main.h
index 56fe060c0ab1..360a49af0c1b 100644
--- a/net/hsr/hsr_main.h
+++ b/net/hsr/hsr_main.h
@@ -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,11 +6,11 @@
  * any later version.
  *
  * Author(s):
- *      2011-2013 Arvid Brodin, arvid.brodin@xdin.com
+ *      2011-2014 Arvid Brodin, arvid.brodin@alten.se
  */
 
-#ifndef _HSR_PRIVATE_H
-#define _HSR_PRIVATE_H
+#ifndef __HSR_PRIVATE_H
+#define __HSR_PRIVATE_H
 
 #include <linux/netdevice.h>
 #include <linux/list.h>
@@ -46,16 +46,16 @@
  * path, LSDU_size, sequence Nr }. But we let eth_header() create { h_dest,
  * h_source, h_proto = 0x88FB }, and add { path, LSDU_size, sequence Nr,
  * encapsulated protocol } instead.
+ *
+ * Field names as defined in the IEC:2010 standard for HSR.
  */
-#define HSR_TAGLEN      6
-
-/* Field names below as defined in the IEC:2010 standard for HSR. */
 struct hsr_tag {
         __be16          path_and_LSDU_size;
         __be16          sequence_nr;
         __be16          encap_proto;
 } __packed;
 
+#define HSR_HLEN        6
 
 /* The helper functions below assumes that 'path' occupies the 4 most
  * significant bits of the 16-bit field shared by 'path' and 'LSDU_size' (or
@@ -159,8 +159,8 @@ struct hsr_priv {
         unsigned char           sup_multicast_addr[ETH_ALEN];
 };
 
-void register_hsr_master(struct hsr_priv *hsr_priv);
-void unregister_hsr_master(struct hsr_priv *hsr_priv);
+void register_hsr_master(struct hsr_priv *hsr);
+void unregister_hsr_master(struct hsr_priv *hsr);
 bool is_hsr_slave(struct net_device *dev);
 
-#endif /*  _HSR_PRIVATE_H */
+#endif /*  __HSR_PRIVATE_H */
diff --git a/net/hsr/hsr_netlink.c b/net/hsr/hsr_netlink.c
index 01a5261ac7a5..bea250ec3586 100644
--- a/net/hsr/hsr_netlink.c
+++ b/net/hsr/hsr_netlink.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
  *
  * Routines for handling Netlink messages for HSR.
  */
@@ -63,21 +63,21 @@ static int hsr_newlink(struct net *src_net, struct net_device *dev,
 
 static int hsr_fill_info(struct sk_buff *skb, const struct net_device *dev)
 {
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
 
-        hsr_priv = netdev_priv(dev);
+        hsr = netdev_priv(dev);
 
-        if (hsr_priv->slave[0])
-                if (nla_put_u32(skb, IFLA_HSR_SLAVE1, hsr_priv->slave[0]->ifindex))
+        if (hsr->slave[0])
+                if (nla_put_u32(skb, IFLA_HSR_SLAVE1, hsr->slave[0]->ifindex))
                         goto nla_put_failure;
 
-        if (hsr_priv->slave[1])
-                if (nla_put_u32(skb, IFLA_HSR_SLAVE2, hsr_priv->slave[1]->ifindex))
+        if (hsr->slave[1])
+                if (nla_put_u32(skb, IFLA_HSR_SLAVE2, hsr->slave[1]->ifindex))
                         goto nla_put_failure;
 
         if (nla_put(skb, IFLA_HSR_SUPERVISION_ADDR, ETH_ALEN,
-                    hsr_priv->sup_multicast_addr) ||
-            nla_put_u16(skb, IFLA_HSR_SEQ_NR, hsr_priv->sequence_nr))
+                    hsr->sup_multicast_addr) ||
+            nla_put_u16(skb, IFLA_HSR_SEQ_NR, hsr->sequence_nr))
                 goto nla_put_failure;
 
         return 0;
@@ -128,7 +128,7 @@ static const struct genl_multicast_group hsr_mcgrps[] = {
  * over one of the slave interfaces. This would indicate an open network ring
  * (i.e. a link has failed somewhere).
  */
-void hsr_nl_ringerror(struct hsr_priv *hsr_priv, unsigned char addr[ETH_ALEN],
+void hsr_nl_ringerror(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN],
                       enum hsr_dev_idx dev_idx)
 {
         struct sk_buff *skb;
@@ -148,8 +148,8 @@ void hsr_nl_ringerror(struct hsr_priv *hsr_priv, unsigned char addr[ETH_ALEN],
         if (res < 0)
                 goto nla_put_failure;
 
-        if (hsr_priv->slave[dev_idx])
-                ifindex = hsr_priv->slave[dev_idx]->ifindex;
+        if (hsr->slave[dev_idx])
+                ifindex = hsr->slave[dev_idx]->ifindex;
         else
                 ifindex = -1;
         res = nla_put_u32(skb, HSR_A_IFINDEX, ifindex);
@@ -165,13 +165,13 @@ nla_put_failure:
         kfree_skb(skb);
 
 fail:
-        netdev_warn(hsr_priv->dev, "Could not send HSR ring error message\n");
+        netdev_warn(hsr->dev, "Could not send HSR ring error message\n");
 }
 
 /* This is called when we haven't heard from the node with MAC address addr for
  * some time (just before the node is removed from the node table/list).
  */
-void hsr_nl_nodedown(struct hsr_priv *hsr_priv, unsigned char addr[ETH_ALEN])
+void hsr_nl_nodedown(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN])
 {
         struct sk_buff *skb;
         void *msg_head;
@@ -199,7 +199,7 @@ nla_put_failure:
         kfree_skb(skb);
 
 fail:
-        netdev_warn(hsr_priv->dev, "Could not send HSR node down\n");
+        netdev_warn(hsr->dev, "Could not send HSR node down\n");
 }
 
 
@@ -220,7 +220,7 @@ static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info)
         /* For sending */
         struct sk_buff *skb_out;
         void *msg_head;
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
         unsigned char hsr_node_addr_b[ETH_ALEN];
         int hsr_node_if1_age;
         u16 hsr_node_if1_seq;
@@ -267,8 +267,8 @@ static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info)
         if (res < 0)
                 goto nla_put_failure;
 
-        hsr_priv = netdev_priv(hsr_dev);
-        res = hsr_get_node_data(hsr_priv,
+        hsr = netdev_priv(hsr_dev);
+        res = hsr_get_node_data(hsr,
                         (unsigned char *) nla_data(info->attrs[HSR_A_NODE_ADDR]),
                         hsr_node_addr_b,
                         &addr_b_ifindex,
@@ -301,9 +301,9 @@ static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info)
         res = nla_put_u16(skb_out, HSR_A_IF1_SEQ, hsr_node_if1_seq);
         if (res < 0)
                 goto nla_put_failure;
-        if (hsr_priv->slave[0])
+        if (hsr->slave[0])
                 res = nla_put_u32(skb_out, HSR_A_IF1_IFINDEX,
-                                                hsr_priv->slave[0]->ifindex);
+                                                hsr->slave[0]->ifindex);
         if (res < 0)
                 goto nla_put_failure;
 
@@ -313,9 +313,9 @@ static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info)
         res = nla_put_u16(skb_out, HSR_A_IF2_SEQ, hsr_node_if2_seq);
         if (res < 0)
                 goto nla_put_failure;
-        if (hsr_priv->slave[1])
+        if (hsr->slave[1])
                 res = nla_put_u32(skb_out, HSR_A_IF2_IFINDEX,
-                                                hsr_priv->slave[1]->ifindex);
+                                                hsr->slave[1]->ifindex);
 
         genlmsg_end(skb_out, msg_head);
         genlmsg_unicast(genl_info_net(info), skb_out, info->snd_portid);
@@ -345,7 +345,7 @@ static int hsr_get_node_list(struct sk_buff *skb_in, struct genl_info *info)
         /* For sending */
         struct sk_buff *skb_out;
         void *msg_head;
-        struct hsr_priv *hsr_priv;
+        struct hsr_priv *hsr;
         void *pos;
         unsigned char addr[ETH_ALEN];
         int res;
@@ -385,17 +385,17 @@ static int hsr_get_node_list(struct sk_buff *skb_in, struct genl_info *info)
         if (res < 0)
                 goto nla_put_failure;
 
-        hsr_priv = netdev_priv(hsr_dev);
+        hsr = netdev_priv(hsr_dev);
 
         rcu_read_lock();
-        pos = hsr_get_next_node(hsr_priv, NULL, addr);
+        pos = hsr_get_next_node(hsr, NULL, addr);
         while (pos) {
                 res = nla_put(skb_out, HSR_A_NODE_ADDR, ETH_ALEN, addr);
                 if (res < 0) {
                         rcu_read_unlock();
                         goto nla_put_failure;
                 }
-                pos = hsr_get_next_node(hsr_priv, pos, addr);
+                pos = hsr_get_next_node(hsr, pos, addr);
         }
         rcu_read_unlock();
 
diff --git a/net/hsr/hsr_netlink.h b/net/hsr/hsr_netlink.h
index d4579dcc3c7d..3047f9cea5f5 100644
--- a/net/hsr/hsr_netlink.h
+++ b/net/hsr/hsr_netlink.h
@@ -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
  */
 
 #ifndef __HSR_NETLINK_H
@@ -21,9 +21,9 @@ struct hsr_priv;
 int __init hsr_netlink_init(void);
 void __exit hsr_netlink_exit(void);
 
-void hsr_nl_ringerror(struct hsr_priv *hsr_priv, unsigned char addr[ETH_ALEN],
+void hsr_nl_ringerror(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN],
                       int dev_idx);
-void hsr_nl_nodedown(struct hsr_priv *hsr_priv, unsigned char addr[ETH_ALEN]);
+void hsr_nl_nodedown(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN]);
 void hsr_nl_framedrop(int dropcount, int dev_idx);
 void hsr_nl_linkdown(int dev_idx);