/* rtmac_vnic.c
 *
 * rtmac - real-time networking media access control subsystem
 * Copyright (C) 2002      Marc Kleine-Budde <kleine-budde@gmx.de>,
 *               2003-2005 Jan Kiszka <Jan.Kiszka@web.de>
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/moduleparam.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/rtnetlink.h>

#include <rtnet_internal.h>
#include <rtdev.h>
#include <rtnet_port.h> /* for netdev_priv() */
#include <rtmac/rtmac_disc.h>
#include <rtmac/rtmac_proto.h>
#include <rtmac/rtmac_vnic.h>

static unsigned int vnic_rtskbs = DEFAULT_VNIC_RTSKBS;
module_param(vnic_rtskbs, uint, 0444);
MODULE_PARM_DESC(vnic_rtskbs,
		 "Number of realtime socket buffers per virtual NIC");

static rtdm_nrtsig_t vnic_signal;
static struct rtskb_queue rx_queue;

int rtmac_vnic_rx(struct rtskb *rtskb, u16 type)
{
	struct rtmac_priv *mac_priv = rtskb->rtdev->mac_priv;
	struct rtskb_pool *pool = &mac_priv->vnic_skb_pool;

	if (rtskb_acquire(rtskb, pool) != 0) {
		mac_priv->vnic_stats.rx_dropped++;
		kfree_rtskb(rtskb);
		return -1;
	}

	rtskb->protocol = type;

	if (rtskb_queue_tail_check(&rx_queue, rtskb))
		rtdm_nrtsig_pend(&vnic_signal);

	return 0;
}

static void rtmac_vnic_signal_handler(rtdm_nrtsig_t *nrtsig, void *arg)
{
	struct rtskb *rtskb;
	struct sk_buff *skb;
	unsigned hdrlen;
	struct net_device_stats *stats;
	struct rtnet_device *rtdev;

	while (1) {
		rtskb = rtskb_dequeue(&rx_queue);
		if (!rtskb)
			break;

		rtdev = rtskb->rtdev;
		hdrlen = rtdev->hard_header_len;

		skb = dev_alloc_skb(hdrlen + rtskb->len + 2);
		if (skb) {
			/* the rtskb stamp is useless (different clock), get new one */
			__net_timestamp(skb);

			skb_reserve(skb,
				    2); /* Align IP on 16 byte boundaries */

			/* copy Ethernet header */
			memcpy(skb_put(skb, hdrlen),
			       rtskb->data - hdrlen - sizeof(struct rtmac_hdr),
			       hdrlen);

			/* patch the protocol field in the original Ethernet header */
			((struct ethhdr *)skb->data)->h_proto = rtskb->protocol;

			/* copy data */
			memcpy(skb_put(skb, rtskb->len), rtskb->data,
			       rtskb->len);

			skb->dev = rtskb->rtdev->mac_priv->vnic;
			skb->protocol = eth_type_trans(skb, skb->dev);

			stats = &rtskb->rtdev->mac_priv->vnic_stats;

			kfree_rtskb(rtskb);

			stats->rx_packets++;
			stats->rx_bytes += skb->len;

			netif_rx(skb);
		} else {
			printk("RTmac: VNIC fails to allocate linux skb\n");
			kfree_rtskb(rtskb);
		}
	}
}

static int rtmac_vnic_copy_mac(struct net_device *dev)
{
	dev_addr_set(dev,
		     (*(struct rtnet_device **)netdev_priv(dev))->dev_addr);

	return 0;
}

int rtmac_vnic_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct rtnet_device *rtdev = *(struct rtnet_device **)netdev_priv(dev);
	struct net_device_stats *stats = &rtdev->mac_priv->vnic_stats;
	struct rtskb_pool *pool = &rtdev->mac_priv->vnic_skb_pool;
	struct ethhdr *ethernet = (struct ethhdr *)skb->data;
	struct rtskb *rtskb;
	int res;
	int data_len;

	rtskb = alloc_rtskb((skb->len + sizeof(struct rtmac_hdr) + 15) & ~15,
			    pool);
	if (!rtskb)
		return NETDEV_TX_BUSY;

	rtskb_reserve(rtskb, rtdev->hard_header_len + sizeof(struct rtmac_hdr));

	data_len = skb->len - dev->hard_header_len;
	memcpy(rtskb_put(rtskb, data_len), skb->data + dev->hard_header_len,
	       data_len);

	res = rtmac_add_header(rtdev, ethernet->h_dest, rtskb,
			       ntohs(ethernet->h_proto), RTMAC_FLAG_TUNNEL);
	if (res < 0) {
		stats->tx_dropped++;
		kfree_rtskb(rtskb);
		goto done;
	}

	RTNET_ASSERT(rtdev->mac_disc->nrt_packet_tx != NULL, kfree_rtskb(rtskb);
		     goto done;);

	res = rtdev->mac_disc->nrt_packet_tx(rtskb);
	if (res < 0) {
		stats->tx_dropped++;
		kfree_rtskb(rtskb);
	} else {
		stats->tx_packets++;
		stats->tx_bytes += skb->len;
	}

done:
	dev_kfree_skb(skb);
	return NETDEV_TX_OK;
}

static struct net_device_stats *rtmac_vnic_get_stats(struct net_device *dev)
{
	return &(*(struct rtnet_device **)netdev_priv(dev))
			->mac_priv->vnic_stats;
}

static int rtmac_vnic_change_mtu(struct net_device *dev, int new_mtu)
{
	if ((new_mtu < 68) ||
	    ((unsigned)new_mtu > 1500 - sizeof(struct rtmac_hdr)))
		return -EINVAL;
	dev->mtu = new_mtu;
	return 0;
}

void rtmac_vnic_set_max_mtu(struct rtnet_device *rtdev, unsigned int max_mtu)
{
	struct rtmac_priv *mac_priv = rtdev->mac_priv;
	struct net_device *vnic = mac_priv->vnic;
	unsigned int prev_mtu = mac_priv->vnic_max_mtu;

	mac_priv->vnic_max_mtu = max_mtu - sizeof(struct rtmac_hdr);

	/* set vnic mtu in case max_mtu is smaller than the current mtu or
       the current mtu was set to previous max_mtu */
	rtnl_lock();
	if ((vnic->mtu > mac_priv->vnic_max_mtu) ||
	    (prev_mtu == mac_priv->vnic_max_mtu)) {
		dev_set_mtu(vnic, mac_priv->vnic_max_mtu);
	}
	rtnl_unlock();
}

static struct net_device_ops vnic_netdev_ops = {
	.ndo_open = rtmac_vnic_copy_mac,
	.ndo_get_stats = rtmac_vnic_get_stats,
	.ndo_change_mtu = rtmac_vnic_change_mtu,
};

static void rtmac_vnic_setup(struct net_device *dev)
{
	ether_setup(dev);

	dev->netdev_ops = &vnic_netdev_ops;
	dev->flags &= ~IFF_MULTICAST;
}

int rtmac_vnic_add(struct rtnet_device *rtdev, vnic_xmit_handler vnic_xmit)
{
	int res;
	struct rtmac_priv *mac_priv = rtdev->mac_priv;
	struct net_device *vnic;
	char buf[IFNAMSIZ];

	/* does the discipline request vnic support? */
	if (!vnic_xmit)
		return 0;

	mac_priv->vnic = NULL;
	mac_priv->vnic_max_mtu = rtdev->mtu - sizeof(struct rtmac_hdr);
	memset(&mac_priv->vnic_stats, 0, sizeof(mac_priv->vnic_stats));

	/* create the rtskb pool */
	if (rtskb_pool_init(&mac_priv->vnic_skb_pool, vnic_rtskbs, NULL, NULL) <
	    vnic_rtskbs) {
		res = -ENOMEM;
		goto error;
	}

	snprintf(buf, sizeof(buf), "vnic%d", rtdev->ifindex - 1);

	vnic = alloc_netdev(sizeof(struct rtnet_device *), buf,
			    NET_NAME_UNKNOWN, rtmac_vnic_setup);
	if (!vnic) {
		res = -ENOMEM;
		goto error;
	}

	vnic_netdev_ops.ndo_start_xmit = vnic_xmit;
	vnic->mtu = mac_priv->vnic_max_mtu;
	*(struct rtnet_device **)netdev_priv(vnic) = rtdev;
	rtmac_vnic_copy_mac(vnic);

	res = register_netdev(vnic);
	if (res < 0)
		goto error;

	mac_priv->vnic = vnic;

	return 0;

error:
	rtskb_pool_release(&mac_priv->vnic_skb_pool);
	return res;
}

int rtmac_vnic_unregister(struct rtnet_device *rtdev)
{
	struct rtmac_priv *mac_priv = rtdev->mac_priv;

	if (mac_priv->vnic) {
		rtskb_pool_release(&mac_priv->vnic_skb_pool);
		unregister_netdev(mac_priv->vnic);
		free_netdev(mac_priv->vnic);
		mac_priv->vnic = NULL;
	}

	return 0;
}

#ifdef CONFIG_XENO_OPT_VFILE
int rtnet_rtmac_vnics_show(struct xnvfile_regular_iterator *it, void *d)
{
	struct rtnet_device *rtdev;
	int i;
	int err;

	xnvfile_printf(it, "RT-NIC name\tVNIC name\n");

	for (i = 1; i <= MAX_RT_DEVICES; i++) {
		rtdev = rtdev_get_by_index(i);
		if (rtdev == NULL)
			continue;

		err = mutex_lock_interruptible(&rtdev->nrt_lock);
		if (err < 0) {
			rtdev_dereference(rtdev);
			return err;
		}

		if (rtdev->mac_priv != NULL) {
			struct rtmac_priv *rtmac;

			rtmac = (struct rtmac_priv *)rtdev->mac_priv;
			xnvfile_printf(it, "%-15s %s\n", rtdev->name,
				       rtmac->vnic->name);
		}

		mutex_unlock(&rtdev->nrt_lock);
		rtdev_dereference(rtdev);
	}

	return 0;
}
#endif /* CONFIG_XENO_OPT_VFILE */

int __init rtmac_vnic_module_init(void)
{
	rtskb_queue_init(&rx_queue);

	rtdm_nrtsig_init(&vnic_signal, rtmac_vnic_signal_handler, NULL);

	return 0;
}

void rtmac_vnic_module_cleanup(void)
{
	struct rtskb *rtskb;

	rtdm_nrtsig_destroy(&vnic_signal);

	while ((rtskb = rtskb_dequeue(&rx_queue)) != NULL) {
		kfree_rtskb(rtskb);
	}
}