/* Copyright 2011-2013 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
   * Software Foundation; either version 2 of the License, or (at your option)
   * any later version.
   *
   * Author(s):
   *	2011-2013 Arvid Brodin, arvid.brodin@xdin.com
   *
   * In addition to routines for registering and unregistering HSR support, this
   * file also contains the receive routine that handles all incoming frames with
   * Ethertype (protocol) ETH_P_PRP (HSRv0), and network device event handling.
   */
  
  #include <linux/netdevice.h>
  #include <linux/rculist.h>
  #include <linux/timer.h>
  #include <linux/etherdevice.h>
  #include "hsr_main.h"
  #include "hsr_device.h"
  #include "hsr_netlink.h"
  #include "hsr_framereg.h"
  
  
  /* List of all registered virtual HSR devices */
  static LIST_HEAD(hsr_list);
  
  void register_hsr_master(struct hsr_priv *hsr_priv)
  {
  	list_add_tail_rcu(&hsr_priv->hsr_list, &hsr_list);
  }
  
  void unregister_hsr_master(struct hsr_priv *hsr_priv)
  {
  	struct hsr_priv *hsr_priv_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);
  			return;
  		}
  }
  
  bool is_hsr_slave(struct net_device *dev)
  {
  	struct hsr_priv *hsr_priv_it;
  
  	list_for_each_entry_rcu(hsr_priv_it, &hsr_list, hsr_list) {
  		if (dev == hsr_priv_it->slave[0])
  			return true;
  		if (dev == hsr_priv_it->slave[1])
  			return true;
  	}
  
  	return false;
  }
  
  
  /* If dev is a HSR slave device, return the virtual master device. Return NULL
   * otherwise.
   */
  static struct hsr_priv *get_hsr_master(struct net_device *dev)
  {
  	struct hsr_priv *hsr_priv;
  
  	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])) {
  			rcu_read_unlock();
  			return hsr_priv;
  		}
  
  	rcu_read_unlock();
  	return NULL;
  }
  
  
  /* 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,
  					  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];
  
  	return NULL;
  }
  
  
  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;
  	int old_operstate;
  	int mtu_max;
  	int res;
  	struct net_device *dev;
  
  	dev = netdev_notifier_info_to_dev(ptr);
  
  	hsr_priv = get_hsr_master(dev);
  	if (hsr_priv) {
  		/* dev is a slave device */
  		slave = dev;
  		other_slave = get_other_slave(hsr_priv, 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];
  	}
  
  	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);
  		/* 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);
  		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)
  			break;
  
  		if (dev == hsr_priv->slave[0])
  			memcpy(hsr_priv->dev->dev_addr,
  			       hsr_priv->slave[0]->dev_addr, ETH_ALEN);
  
  		/* 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);
  		if (res)
  			netdev_warn(hsr_priv->dev,
  				    "Could not update HSR node address.
  ");
  
  		if (dev == hsr_priv->slave[0])
  			call_netdevice_notifiers(NETDEV_CHANGEADDR, hsr_priv->dev);
  		break;
  	case NETDEV_CHANGEMTU:
  		if (dev == hsr_priv->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);
  		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;
  
  		/* There should really be a way to set a new slave device... */
  
  		break;
  	case NETDEV_PRE_TYPE_CHANGE:
  		/* HSR works only on Ethernet devices. Refuse slave to change
  		 * its type.
  		 */
  		return NOTIFY_BAD;
  	}
  
  	return NOTIFY_DONE;
  }
  
  
  static struct timer_list prune_timer;
  
  static void prune_nodes_all(unsigned long data)
  {
  	struct hsr_priv *hsr_priv;
  
  	rcu_read_lock();
  	list_for_each_entry_rcu(hsr_priv, &hsr_list, hsr_list)
  		hsr_prune_nodes(hsr_priv);
  	rcu_read_unlock();
  
  	prune_timer.expires = jiffies + msecs_to_jiffies(PRUNE_PERIOD);
  	add_timer(&prune_timer);
  }
  
  
  static struct sk_buff *hsr_pull_tag(struct sk_buff *skb)
  {
  	struct hsr_tag *hsr_tag;
  	struct sk_buff *skb2;
  
  	skb2 = skb_share_check(skb, GFP_ATOMIC);
  	if (unlikely(!skb2))
  		goto err_free;
  	skb = skb2;
  
  	if (unlikely(!pskb_may_pull(skb, HSR_TAGLEN)))
  		goto err_free;
  
  	hsr_tag = (struct hsr_tag *) skb->data;
  	skb->protocol = hsr_tag->encap_proto;
  	skb_pull(skb, HSR_TAGLEN);
  
  	return skb;
  
  err_free:
  	kfree_skb(skb);
  	return NULL;
  }
  
  
  /* The uses I can see for these HSR supervision frames are:
   * 1) Use the frames that are sent after node initialization ("HSR_TLV.Type =
   *    22") to reset any sequence_nr counters belonging to that node. Useful if
   *    the other node's counter has been reset for some reason.
   *    --
   *    Or not - resetting the counter and bridging the frame would create a
   *    loop, unfortunately.
   *
   * 2) Use the LifeCheck frames to detect ring breaks. I.e. if no LifeCheck
   *    frame is received from a particular node, we know something is wrong.
   *    We just register these (as with normal frames) and throw them away.
   *
   * 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)
  {
  	struct hsr_sup_tag *hsr_stag;
  
  	if (!ether_addr_equal(eth_hdr(skb)->h_dest,
  			      hsr_priv->sup_multicast_addr))
  		return false;
  
  	hsr_stag = (struct hsr_sup_tag *) skb->data;
  	if (get_hsr_stag_path(hsr_stag) != 0x0f)
  		return false;
  	if ((hsr_stag->HSR_TLV_Type != HSR_TLV_ANNOUNCE) &&
  	    (hsr_stag->HSR_TLV_Type != HSR_TLV_LIFE_CHECK))
  		return false;
  	if (hsr_stag->HSR_TLV_Length != 12)
  		return false;
  
  	return true;
  }
  
  
  /* Implementation somewhat according to IEC-62439-3, p. 43
   */
  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 net_device *other_slave;
  	struct node_entry *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);
  
  	if (!hsr_priv) {
  		/* 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]) {
  		dev_in_idx = HSR_DEV_SLAVE_A;
  		dev_other_idx = HSR_DEV_SLAVE_B;
  	} else {
  		dev_in_idx = HSR_DEV_SLAVE_B;
  		dev_other_idx = HSR_DEV_SLAVE_A;
  	}
  
  	node = hsr_find_node(&hsr_priv->self_node_db, skb);
  	if (node) {
  		/* Always kill frames sent by ourselves */
  		kfree_skb(skb);
  		return NET_RX_SUCCESS;
  	}
  
  	/* Is this frame a candidate for local reception? */
  	deliver_to_self = false;
  	if ((skb->pkt_type == PACKET_HOST) ||
  	    (skb->pkt_type == PACKET_MULTICAST) ||
  	    (skb->pkt_type == PACKET_BROADCAST))
  		deliver_to_self = true;
  	else if (ether_addr_equal(eth_hdr(skb)->h_dest,
  				     hsr_priv->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);
  
  	if (is_supervision_frame(hsr_priv, skb)) {
  		skb_pull(skb, sizeof(struct hsr_sup_tag));
  		node = hsr_merge_node(hsr_priv, node, skb, dev_in_idx);
  		if (!node) {
  			rcu_read_unlock(); /* node_db */
  			kfree_skb(skb);
  			hsr_priv->dev->stats.rx_dropped++;
  			return NET_RX_DROP;
  		}
  		skb_push(skb, sizeof(struct hsr_sup_tag));
  		deliver_to_self = false;
  	}
  
  	if (!node) {
  		/* Source node unknown; this might be a HSR frame from
  		 * another net (different multicast address). Ignore it.
  		 */
  		rcu_read_unlock(); /* node_db */
  		kfree_skb(skb);
  		return NET_RX_SUCCESS;
  	}
  
  	/* Register ALL incoming frames as outgoing through the other interface.
  	 * This allows us to register frames as incoming only if they are valid
  	 * for the receiving interface, without using a specific counter for
  	 * incoming frames.
  	 */
  	dup_out = hsr_register_frame_out(node, dev_other_idx, skb);
  	if (!dup_out)
  		hsr_register_frame_in(node, dev_in_idx);
  
  	/* Forward this frame? */
  	if (!dup_out && (skb->pkt_type != PACKET_HOST))
  		other_slave = get_other_slave(hsr_priv, dev);
  	else
  		other_slave = NULL;
  
  	if (hsr_register_frame_out(node, HSR_DEV_MASTER, skb))
  		deliver_to_self = false;
  
  	rcu_read_unlock(); /* node_db */
  
  	if (!deliver_to_self && !other_slave) {
  		kfree_skb(skb);
  		/* Circulated frame; silently remove it. */
  		return NET_RX_SUCCESS;
  	}
  
  	skb_deliver = skb;
  	if (deliver_to_self && other_slave) {
  		/* skb_clone() is not enough since we will strip the hsr tag
  		 * and do address substitution below
  		 */
  		skb_deliver = pskb_copy(skb, GFP_ATOMIC);
  		if (!skb_deliver) {
  			deliver_to_self = false;
  			hsr_priv->dev->stats.rx_dropped++;
  		}
  	}
  
  	if (deliver_to_self) {
  		bool multicast_frame;
  
  		skb_deliver = hsr_pull_tag(skb_deliver);
  		if (!skb_deliver) {
  			hsr_priv->dev->stats.rx_dropped++;
  			goto forward;
  		}
  #if !defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
  		/* Move everything in the header that is after the HSR tag,
  		 * to work around alignment problems caused by the 6-byte HSR
  		 * 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,
  			skb_headlen(skb_deliver));
  
  		/* Adjust skb members so they correspond with the move above.
  		 * This cannot possibly underflow skb->data since hsr_pull_tag()
  		 * above succeeded.
  		 * At this point in the protocol stack, the transport and
  		 * network headers have not been set yet, and we haven't touched
  		 * 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;
  #endif
  		skb_deliver->dev = hsr_priv->dev;
  		hsr_addr_subst_source(hsr_priv, 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++;
  		} else {
  			hsr_priv->dev->stats.rx_packets++;
  			hsr_priv->dev->stats.rx_bytes += skb->len;
  			if (multicast_frame)
  				hsr_priv->dev->stats.multicast++;
  		}
  	}
  
  forward:
  	if (other_slave) {
  		skb_push(skb, ETH_HLEN);
  		skb->dev = other_slave;
  		dev_queue_xmit(skb);
  	}
  
  	return NET_RX_SUCCESS;
  }
  
  
  static struct packet_type hsr_pt __read_mostly = {
  	.type = htons(ETH_P_PRP),
  	.func = hsr_rcv,
  };
  
  static struct notifier_block hsr_nb = {
  	.notifier_call = hsr_netdev_notify,	/* Slave event notifications */
  };
  
  
  static int __init hsr_init(void)
  {
  	int res;
  
  	BUILD_BUG_ON(sizeof(struct hsr_tag) != HSR_TAGLEN);
  
  	dev_add_pack(&hsr_pt);
  
  	init_timer(&prune_timer);
  	prune_timer.function = prune_nodes_all;
  	prune_timer.data = 0;
  	prune_timer.expires = jiffies + msecs_to_jiffies(PRUNE_PERIOD);
  	add_timer(&prune_timer);
  
  	register_netdevice_notifier(&hsr_nb);
  
  	res = hsr_netlink_init();
  
  	return res;
  }
  
  static void __exit hsr_exit(void)
  {
  	unregister_netdevice_notifier(&hsr_nb);
  	del_timer(&prune_timer);
  	hsr_netlink_exit();
  	dev_remove_pack(&hsr_pt);
  }
  
  module_init(hsr_init);
  module_exit(hsr_exit);
  MODULE_LICENSE("GPL");