/*
 * snull.c --  the Simple Network Utility
 *
 * Copyright (C) 2001 Alessandro Rubini and Jonathan Corbet
 * Copyright (C) 2001 O'Reilly & Associates
 *
 * The source code in this file can be freely used, adapted,
 * and redistributed in source or binary form, so long as an
 * acknowledgment appears in derived source files.  The citation
 * should list that the code comes from the book "Linux Device
 * Drivers" by Alessandro Rubini and Jonathan Corbet, published
 * by O'Reilly & Associates.   No warranty is attached;
 * we cannot take responsibility for errors or fitness for use.
 *
 * $Id: snull.c,v 1.21 2004/11/05 02:36:03 rubini Exp $
 
    Modified by Doug Abbott to improve readability
    11-27-09    Upgraded to "new" NAPI      DLA
 */

#include <linux/module.h>

#include <linux/kernel.h> /* printk() */
#include <linux/slab.h> /* kmalloc() */
#include <linux/errno.h>  /* error codes */
#include <linux/types.h>  /* size_t */

#include <linux/interrupt.h>
#include <linux/netdevice.h>   /* struct device, and other headers */
#include <linux/etherdevice.h> /* eth_type_trans */
#include <linux/ip.h>          /* struct iphdr */
#include <linux/skbuff.h>
#include <asm/checksum.h>

#include "snull.h"

MODULE_AUTHOR("Alessandro Rubini, Jonathan Corbet");
MODULE_LICENSE("Dual BSD/GPL");

/*
 * Transmitter lockup simulation, normally disabled.
 */
static int lockup = 0;
module_param(lockup, int, 0);

static int timeout = SNULL_TIMEOUT;
module_param(timeout, int, 0);
/*
 * Do we run in NAPI mode?
 */
static int use_napi = 0;
module_param(use_napi, int, 0);

/*
 * A structure representing an in-flight packet.
 */
struct snull_packet {
	struct snull_packet *next;
	struct net_device *dev;
	int	datalen;
	u8 data[ETH_DATA_LEN];
};

int pool_size = 8;
module_param(pool_size, int, 0);

/*
 * This structure is private to each device. It is used to pass
 * packets in and out, so there is place for a packet
 */
struct snull_priv {
	struct net_device_stats stats;
    struct napi_struct napi;
	int status;
	struct snull_packet *ppool;
	struct snull_packet *rx_queue;  /* List of incoming packets */
	int rx_int_enabled;
	int tx_packetlen;
	u8 *tx_packetdata;
	struct sk_buff *skb;
	spinlock_t lock;
};

void snull_setup_pool (struct net_device *dev)
/*
 * Set up a device's packet pool.
 */
{
	struct snull_priv *priv = netdev_priv (dev);
	int i;
	struct snull_packet *pkt;

	priv->ppool = NULL;
	for (i = 0; i < pool_size; i++)
    {
		pkt = kmalloc (sizeof (struct snull_packet), GFP_KERNEL);
		if (pkt == NULL)
        {
			printk (KERN_NOTICE "Ran out of memory allocating packet pool\n");
			return;
		}
		pkt->dev = dev;
		pkt->next = priv->ppool;
		priv->ppool = pkt;
	}
}

void snull_teardown_pool (struct net_device *dev)
{
	struct snull_priv *priv = netdev_priv (dev);
	struct snull_packet *pkt;
    
	while ((pkt = priv->ppool))
    {
		priv->ppool = pkt->next;
		kfree (pkt);
		/* FIXME - in-flight packets ? */
	}
}    

/*
 * Buffer/pool management.
 */
struct snull_packet *snull_get_tx_buffer (struct net_device *dev)
/*
    Get a transmit buffer
*/
{
	struct snull_priv *priv = netdev_priv( dev);
	unsigned long flags;
	struct snull_packet *pkt;
    
	spin_lock_irqsave (&priv->lock, flags);
	pkt = priv->ppool;
	priv->ppool = pkt->next;

	if (priv->ppool == NULL)
    {
		printk (KERN_INFO "Pool empty\n");
		netif_stop_queue (dev);
	}
	spin_unlock_irqrestore (&priv->lock, flags);
	return pkt;
}

void snull_release_buffer (struct snull_packet *pkt)
/*
    Return a transmit buffer to the pool
*/
{
	unsigned long flags;
	struct snull_priv *priv = netdev_priv (pkt->dev);
	
	spin_lock_irqsave (&priv->lock, flags);
	pkt->next = priv->ppool;
	priv->ppool = pkt;
	spin_unlock_irqrestore (&priv->lock, flags);
    
	if (netif_queue_stopped (pkt->dev) && pkt->next == NULL)
		netif_wake_queue (pkt->dev);
}

void snull_enqueue_buf (struct net_device *dev, struct snull_packet *pkt)
/*
    Put a buffer on the receive queue
*/
{
	unsigned long flags;
	struct snull_priv *priv = netdev_priv (dev);

	spin_lock_irqsave(&priv->lock, flags);
	pkt->next = priv->rx_queue;  /* FIXME - misorders packets */
	priv->rx_queue = pkt;
	spin_unlock_irqrestore(&priv->lock, flags);
}

struct snull_packet *snull_dequeue_buf (struct net_device *dev)
/*
    Pull a buffer off the receive queue
*/
{
	struct snull_priv *priv = netdev_priv (dev);
	struct snull_packet *pkt;
	unsigned long flags;

	spin_lock_irqsave (&priv->lock, flags);
	pkt = priv->rx_queue;
	if (pkt != NULL)
		priv->rx_queue = pkt->next;
	spin_unlock_irqrestore (&priv->lock, flags);
	return pkt;
}

static void snull_rx_ints (struct snull_priv *priv, int enable)
/*
 * Enable and disable receive interrupts.
 */
{
	priv->rx_int_enabled = enable;
}
    
/*
 * Open and close
 */
int snull_open (struct net_device *dev)
{
	/* request_region(), request_irq(), ....  (like fops->open) */

	/* 
	 * Assign the hardware address of the board: use "\0SNULx", where
	 * x is 0 or 1. The first byte is '\0' to avoid being a multicast
	 * address (the first byte of multicast addrs is odd).
	 */
	memcpy (dev->dev_addr, "\0SNUL0", ETH_ALEN);
	if (dev == snull_devs[1])
		dev->dev_addr[ETH_ALEN-1]++; /* \0SNUL1 */
	netif_start_queue (dev);
    
	return 0;
}

int snull_release (struct net_device *dev)
{
    /* release ports, irq and such -- like fops->close */

	netif_stop_queue (dev); /* can't transmit any more */
	return 0;
}

/*
 * Configuration changes (passed on by ifconfig)
 */
int snull_config (struct net_device *dev, struct ifmap *map)
{
	if (dev->flags & IFF_UP) /* can't act on a running interface */
		return -EBUSY;

	/* Don't allow changing the I/O address */
	if (map->base_addr != dev->base_addr)
    {
		printk(KERN_WARNING "snull: Can't change I/O address\n");
		return -EOPNOTSUPP;
	}

	/* Allow changing the IRQ */
	if (map->irq != dev->irq) {
		dev->irq = map->irq;
        	/* request_irq() is delayed to open-time */
	}

	/* ignore other fields */
	return 0;
}

void snull_rx (struct net_device *dev, struct snull_packet *pkt)
/*
 * Receive a packet: retrieve, encapsulate and pass over to upper levels
 */
{
	struct sk_buff *skb;
	struct snull_priv *priv = netdev_priv(dev);
    int i;

	/*
	 * The packet has been retrieved from the transmission
	 * medium. Build an skb around it, so upper layers can handle it
	 */
	skb = dev_alloc_skb (pkt->datalen + NET_IP_ALIGN);
	if (!skb)
    {
		if (printk_ratelimit())
			printk (KERN_NOTICE "snull rx: low on mem - packet dropped\n");
		priv->stats.rx_dropped++;
		return;
	}
/*
    This aligns the IP header on a DMA friendly 16B boundary because
    the preceding Ethernet header is 14 bytes.  (NET_IP_ALIGN = 2)
*/
    skb_reserve (skb, NET_IP_ALIGN);
	memcpy (skb_put (skb, pkt->datalen), pkt->data, pkt->datalen);

	/* Write metadata, and then pass to the receive level */
	skb->dev = dev;
	skb->protocol = eth_type_trans (skb, dev);
	skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */
    
	priv->stats.rx_packets++;
	priv->stats.rx_bytes += pkt->datalen;
	i = netif_rx (skb);
    PDEBUG ("Receive %s data: %p, len: %d, netif_rx: %d\n", dev->name, pkt->data, pkt->datalen, i);
}

#ifdef NAPI
static int snull_poll (struct napi_struct *napi, int budget)
/*
 * The poll implementation for NAPI.
 */
{
	int npackets = 0;
	struct sk_buff *skb;
	struct snull_packet *pkt;
    struct net_device *dev = napi->dev; 
    struct snull_priv *priv = netdev_priv (dev);
    
    PDEBUG ("Poll: device %s, budget = %d\n", dev->name, budget);
    
	while (npackets < budget && priv->rx_queue)
    {
		pkt = snull_dequeue_buf (dev);
		skb = dev_alloc_skb (pkt->datalen + NET_IP_ALIGN);
		if (!skb)
        {
			if (printk_ratelimit())
				printk (KERN_NOTICE "snull: packet dropped\n");
			priv->stats.rx_dropped++;
			snull_release_buffer (pkt);
			continue;
		}
		skb_reserve (skb, NET_IP_ALIGN); /* align IP on 16B boundary */
		memcpy (skb_put (skb, pkt->datalen), pkt->data, pkt->datalen);
		skb->dev = dev;
		skb->protocol = eth_type_trans (skb, dev);
		skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */
		netif_receive_skb (skb);
		
        	/* Maintain stats */
		npackets++;
		priv->stats.rx_packets++;
		priv->stats.rx_bytes += pkt->datalen;
		snull_release_buffer (pkt);
	}
/* If we processed all packets, we're done; tell the kernel and reenable ints */
    PDEBUG ("Poll: npackets = %d\n", npackets);
	if (!priv->rx_queue)
    {
        PDEBUG ("Poll: queue empty\n");
		netif_rx_complete (napi);
		snull_rx_ints (priv, 1);
	}
	return npackets;
}
#endif
        
static irqreturn_t snull_regular_interrupt (int irq, void *dev_id)
/*
 * The typical interrupt entry point
 */
{
	int statusword;
	struct snull_priv *priv;
	struct snull_packet *pkt = NULL;
	/*
	 * As usual, check the "device" pointer to be sure it is
	 * really interrupting.
	 * Then assign "struct device *dev"
	 */
	struct net_device *dev = (struct net_device *) dev_id;
	/* ... and check with hw if it's really ours */

	/* paranoid */
	if (!dev)
		return IRQ_NONE;

	/* Lock the device */
	priv = netdev_priv (dev);
	spin_lock (&priv->lock);

	/* retrieve statusword: real netdevices use I/O instructions */
	statusword = priv->status;
	priv->status = 0;
    PDEBUG ("Int: %s, status = %x\n", dev->name, statusword);
    
	if (statusword & SNULL_RX_INTR)
    {
		/* send it to snull_rx for handling */
		pkt = priv->rx_queue;
		if (pkt)
        {
			priv->rx_queue = pkt->next;
			snull_rx (dev, pkt);
		}
	}
	if (statusword & SNULL_TX_INTR)
    {
		/* a transmission is over: free the skb */
		priv->stats.tx_packets++;
		priv->stats.tx_bytes += priv->tx_packetlen;
		dev_kfree_skb (priv->skb);
	}
	/* Unlock the device and we are done */
	spin_unlock (&priv->lock);
	if (pkt) snull_release_buffer (pkt); /* Do this outside the lock! */

    return IRQ_HANDLED;
}

#ifdef NAPI
/*
 * A NAPI interrupt handler.
 */
static irqreturn_t snull_napi_interrupt (int irq, void *dev_id)
{
	int statusword;
	struct snull_priv *priv;

	/*
	 * As usual, check the "device" pointer for shared handlers.
	 * Then assign "struct device *dev"
	 */
	struct net_device *dev = (struct net_device *) dev_id;
	/* ... and check with hw if it's really ours */

	/* paranoid */
	if (!dev)
		return IRQ_NONE;

	/* Lock the device */
	priv = netdev_priv (dev);
	spin_lock (&priv->lock);

	/* retrieve statusword: real netdevices use I/O instructions */
	statusword = priv->status;
	priv->status = 0;
    PDEBUG ("NAPI int: %s, status = %x\n", dev->name, statusword);
    
	if (statusword & SNULL_RX_INTR)
    {
		snull_rx_ints (priv, 0);  /* Disable further interrupts */
		netif_rx_schedule (&priv->napi);
	}
	if (statusword & SNULL_TX_INTR)
    {
        	/* a transmission is over: free the skb */
		priv->stats.tx_packets++;
		priv->stats.tx_bytes += priv->tx_packetlen;
		dev_kfree_skb (priv->skb);
	}
/* Unlock the device and we are done */
	spin_unlock (&priv->lock);

    return IRQ_HANDLED;
}
#endif

static irqreturn_t (*snull_interrupt) (int, void *);

static void snull_hw_tx (char *buf, int len, struct net_device *src_dev)
{
	/*
     * Transmit a packet (low level interface)

	 * This function deals with hw details. This interface loops
	 * back the packet to the other snull interface (if any).
	 * In other words, this function implements the snull behaviour,
	 * while all other procedures are rather device-independent
	 */
	struct iphdr *ih;
	struct net_device *dest_dev;    // The receiving device
	struct snull_priv *priv;
	u32 *saddr, *daddr;
	struct snull_packet *tx_buffer;
    irqreturn_t ret;
    
	/* I am paranoid. Ain't I? */
	if (len < sizeof(struct ethhdr) + sizeof(struct iphdr))
    {
		printk ("snull: Hmm... packet too short (%i octets)\n", len);
		return;
	}

	if (0)
    { /* enable this conditional to look at the data */
		int i;
		PDEBUG ("len is %i\n" KERN_DEBUG "data:",len);
		for (i=14 ; i<len; i++)
			printk (" %02x",buf[i]&0xff);
		printk ("\n");
	}
	ih = (struct iphdr *) (buf + sizeof(struct ethhdr));
	saddr = &ih->saddr;
	daddr = &ih->daddr;
    PDEBUG ("Transmit from %s, %08x to %08x\n", src_dev->name, ntohl(ih->saddr), ntohl(ih->daddr));

	((u8 *)saddr)[2] ^= 1; /* change the third octet (class C) */
	((u8 *)daddr)[2] ^= 1;

	ih->check = 0;         /* and rebuild the checksum (ip needs it) */
	ih->check = ip_fast_csum ((unsigned char *)ih,ih->ihl);
    PDEBUG ("Addresses diddled. saddr=%08x, daddr=%08x\n", ntohl(ih->saddr), ntohl(ih->daddr));

	/*
	 * Ok, now the packet is ready for transmission: first simulate a
	 * receive interrupt on the twin device, then  a
	 * transmission-done on the transmitting device
	 */
	dest_dev = snull_devs[src_dev == snull_devs[0] ? 1 : 0];
	priv = netdev_priv (dest_dev);
	tx_buffer = snull_get_tx_buffer (src_dev);  // Get a transmit buffer
	tx_buffer->datalen = len;

	memcpy (tx_buffer->data, buf, len);
	snull_enqueue_buf (dest_dev, tx_buffer);  // Put it on the receive queue
    PDEBUG ("tx_buffer = %p, len = %d\n", tx_buffer->data, len);
    
	if (priv->rx_int_enabled)
    {
		priv->status |= SNULL_RX_INTR;
		ret = snull_interrupt (0, dest_dev);
	}
	priv = netdev_priv (src_dev);
	priv->tx_packetlen = len;
	priv->tx_packetdata = buf;
	priv->status |= SNULL_TX_INTR;
    
	if (lockup && ((priv->stats.tx_packets + 1) % lockup) == 0)
    {	/* Simulate a dropped transmit interrupt */
		netif_stop_queue (src_dev);
		PDEBUG ("Simulate lockup at %ld, txp %ld\n", jiffies, (unsigned long) priv->stats.tx_packets);
	}
	else
		snull_interrupt (0, src_dev);
}

int snull_tx (struct sk_buff *skb, struct net_device *dev)
/*
 * Transmit a packet (called by the kernel)
 */
{
	int len;
	char *data, shortpkt[ETH_ZLEN];
	struct snull_priv *priv = netdev_priv (dev);
	
	data = skb->data;
	len = skb->len;
    
	if (len < ETH_ZLEN)
    {  // Don't transmit a short packet.  Use our shortpkt instead
		memset (shortpkt, 0, ETH_ZLEN);
		memcpy (shortpkt, skb->data, skb->len);
		len = ETH_ZLEN;
		data = shortpkt;
	}
	dev->trans_start = jiffies; /* save the timestamp */

	/* Remember the skb, so we can free it at interrupt time */
	priv->skb = skb;

	/* actual delivery of data is device-specific, and not shown here */
	snull_hw_tx (data, len, dev);

	return NETDEV_TX_OK; /* Our simple device can not fail */
}

void snull_tx_timeout (struct net_device *dev)
/*
 * Deal with a transmit timeout.
 */
{
	struct snull_priv *priv = netdev_priv (dev);

	PDEBUG ("Transmit timeout at %ld, latency %ld\n", jiffies, jiffies - dev->trans_start);
        /* Simulate a transmission interrupt to get things moving */
	priv->status = SNULL_TX_INTR;
	snull_interrupt (0, dev);
	priv->stats.tx_errors++;
	netif_wake_queue (dev);
}

int snull_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
/*
 * Ioctl commands 
 */
{
	PDEBUG ("ioctl\n");
	return 0;
}

struct net_device_stats *snull_stats (struct net_device *dev)
/*
 * Return statistics to the caller
 */
{
	struct snull_priv *priv = netdev_priv(dev);
	return &priv->stats;
}

int snull_change_mtu (struct net_device *dev, int new_mtu)
/*
 * The "change_mtu" method is usually not needed.
 * If you need it, it must be like this.
 */
{
	unsigned long flags;
	struct snull_priv *priv = netdev_priv (dev);
	spinlock_t *lock = &priv->lock;
    
	/* check ranges */
	if ((new_mtu < 68) || (new_mtu > 1500))
		return -EINVAL;
	/*
	 * Do anything you need, and the accept the value
	 */
	spin_lock_irqsave( lock, flags);
	dev->mtu = new_mtu;
	spin_unlock_irqrestore (lock, flags);
	return 0; /* success */
}
struct net_device_ops dev_ops = {
    .ndo_open            = snull_open,
    .ndo_stop            = snull_release,
    .ndo_set_config      = snull_config,
    .ndo_start_xmit      = snull_tx,
    .ndo_do_ioctl        = snull_ioctl,
    .ndo_get_stats       = snull_stats,
    .ndo_change_mtu      = snull_change_mtu,  
    .ndo_tx_timeout      = snull_tx_timeout,
};

void snull_init (struct net_device *dev)
/*
 * The init function (sometimes called probe).
 * It is invoked by register_netdev()
 */
{
	struct snull_priv *priv;
    /*
	 * Make the usual checks: check_region(), probe irq, ...  -ENODEV
	 * should be returned if no device found.  No resource should be
	 * grabbed: this is done on open(). 
	 */

    /* 
	 * Then, assign other fields in dev, using ether_setup() and some
	 * hand assignments
	 */
	ether_setup (dev); /* assign some of the fields */

	dev->watchdog_timeo = timeout;
    dev->netdev_ops = &dev_ops;
    
    /* keep the default flags, just add NOARP */
    dev->flags           |= IFF_NOARP;
    dev->features        |= NETIF_F_NO_CSUM;
	/*
	 * Then, initialize the priv field. This encloses the statistics
	 * and a few private fields.
	 */
	priv = netdev_priv (dev);
	memset (priv, 0, sizeof(struct snull_priv));
	spin_lock_init (&priv->lock);
	snull_rx_ints (priv, 1);		/* enable receive interrupts */
	snull_setup_pool (dev);

#ifdef NAPI
    if (use_napi)
    {
        netif_napi_add (dev, &priv->napi, snull_poll, 2);
    }
#endif
    PDEBUG ("init_called for %s\n", dev->name);
}

/*
 * The devices
 */
struct net_device *snull_devs[2];
/*
 * Finally, the module stuff
 */

void snull_cleanup(void)
{
	int i;
    
	for (i = 0; i < 2;  i++)
		if (snull_devs[i])
        {
			unregister_netdev (snull_devs[i]);
			snull_teardown_pool (snull_devs[i]);
			free_netdev (snull_devs[i]);
		}
}

int snull_init_module (void)
{
	int result, i, ret = -ENOMEM;
/*
    Set up the correct interrupt handler
*/
//	snull_interrupt = use_napi ? snull_napi_interrupt : snull_regular_interrupt;
    snull_interrupt = snull_regular_interrupt;

	/* Allocate the devices */
	snull_devs[0] = alloc_netdev (sizeof(struct snull_priv), "sn%d", snull_init);
	snull_devs[1] = alloc_netdev (sizeof(struct snull_priv), "sn%d", snull_init);
    
	if (snull_devs[0] == NULL || snull_devs[1] == NULL)
		goto out;

	ret = -ENODEV;
    PDEBUG ("Registering net devices\n");
	for (i = 0; i < 2;  i++)
		if ((result = register_netdev (snull_devs[i])))
			printk (KERN_WARNING "snull: error %i registering device \"%s\"\n",
					result, snull_devs[i]->name);
		else
			ret = 0;
            
out:
	if (ret) 
		snull_cleanup();
	return ret;
}

module_init(snull_init_module);
module_exit(snull_cleanup);