[mirror_ubuntu-zesty-kernel.git] / drivers / net / mipsnet.c

/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 */

#define DEBUG

#include <linux/init.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/platform_device.h>
#include <asm/mips-boards/simint.h>

#include "mipsnet.h"		/* actual device IO mapping */

#define MIPSNET_VERSION "2005-06-20"

#define mipsnet_reg_address(dev, field) (dev->base_addr + field_offset(field))

static char mipsnet_string[] = "mipsnet";

/*
 * Copy data from the MIPSNET rx data port
 */
static int ioiocpy_frommipsnet(struct net_device *dev, unsigned char *kdata,
			int len)
{
	uint32_t available_len = inl(mipsnet_reg_address(dev, rxDataCount));
	if (available_len < len)
		return -EFAULT;

	for (; len > 0; len--, kdata++)
		*kdata = inb(mipsnet_reg_address(dev, rxDataBuffer));

	return inl(mipsnet_reg_address(dev, rxDataCount));
}

static inline ssize_t mipsnet_put_todevice(struct net_device *dev,
	struct sk_buff *skb)
{
	int count_to_go = skb->len;
	char *buf_ptr = skb->data;

	pr_debug("%s: %s(): telling MIPSNET txDataCount(%d)\n",
		 dev->name, __FUNCTION__, skb->len);

	outl(skb->len, mipsnet_reg_address(dev, txDataCount));

	pr_debug("%s: %s(): sending data to MIPSNET txDataBuffer(%d)\n",
		 dev->name, __FUNCTION__, skb->len);

	for (; count_to_go; buf_ptr++, count_to_go--)
		outb(*buf_ptr, mipsnet_reg_address(dev, txDataBuffer));

	dev->stats.tx_packets++;
	dev->stats.tx_bytes += skb->len;

	return skb->len;
}

static int mipsnet_xmit(struct sk_buff *skb, struct net_device *dev)
{
	pr_debug("%s:%s(): transmitting %d bytes\n",
		 dev->name, __FUNCTION__, skb->len);

	/* Only one packet at a time. Once TXDONE interrupt is serviced, the
	 * queue will be restarted.
	 */
	netif_stop_queue(dev);
	mipsnet_put_todevice(dev, skb);

	return 0;
}

static inline ssize_t mipsnet_get_fromdev(struct net_device *dev, size_t count)
{
	struct sk_buff *skb;
	size_t len = count;

	skb = alloc_skb(len + 2, GFP_KERNEL);
	if (!skb) {
		dev->stats.rx_dropped++;
		return -ENOMEM;
	}

	skb_reserve(skb, 2);
	if (ioiocpy_frommipsnet(dev, skb_put(skb, len), len))
		return -EFAULT;

	skb->protocol = eth_type_trans(skb, dev);
	skb->ip_summed = CHECKSUM_UNNECESSARY;

	pr_debug("%s:%s(): pushing RXed data to kernel\n",
		 dev->name, __FUNCTION__);
	netif_rx(skb);

	dev->stats.rx_packets++;
	dev->stats.rx_bytes += len;

	return count;
}

static irqreturn_t mipsnet_interrupt(int irq, void *dev_id)
{
	struct net_device *dev = dev_id;

	irqreturn_t retval = IRQ_NONE;
	uint64_t interruptFlags;

	if (irq == dev->irq) {
		pr_debug("%s:%s(): irq %d for device\n",
			 dev->name, __FUNCTION__, irq);

		retval = IRQ_HANDLED;

		interruptFlags =
		    inl(mipsnet_reg_address(dev, interruptControl));
		pr_debug("%s:%s(): intCtl=0x%016llx\n", dev->name,
			 __FUNCTION__, interruptFlags);

		if (interruptFlags & MIPSNET_INTCTL_TXDONE) {
			pr_debug("%s:%s(): got TXDone\n",
				 dev->name, __FUNCTION__);
			outl(MIPSNET_INTCTL_TXDONE,
			     mipsnet_reg_address(dev, interruptControl));
			/* only one packet at a time, we are done. */
			netif_wake_queue(dev);
		} else if (interruptFlags & MIPSNET_INTCTL_RXDONE) {
			pr_debug("%s:%s(): got RX data\n",
				 dev->name, __FUNCTION__);
			mipsnet_get_fromdev(dev,
				    inl(mipsnet_reg_address(dev, rxDataCount)));
			pr_debug("%s:%s(): clearing RX int\n",
				 dev->name, __FUNCTION__);
			outl(MIPSNET_INTCTL_RXDONE,
			     mipsnet_reg_address(dev, interruptControl));

		} else if (interruptFlags & MIPSNET_INTCTL_TESTBIT) {
			pr_debug("%s:%s(): got test interrupt\n",
				 dev->name, __FUNCTION__);
			/*
			 * TESTBIT is cleared on read.
			 * And takes effect after a write with 0
			 */
			outl(0, mipsnet_reg_address(dev, interruptControl));
		} else {
			pr_debug("%s:%s(): no valid fags 0x%016llx\n",
				 dev->name, __FUNCTION__, interruptFlags);
			/* Maybe shared IRQ, just ignore, no clearing. */
			retval = IRQ_NONE;
		}

	} else {
		printk(KERN_INFO "%s: %s(): irq %d for unknown device\n",
		       dev->name, __FUNCTION__, irq);
		retval = IRQ_NONE;
	}
	return retval;
}

static int mipsnet_open(struct net_device *dev)
{
	int err;
	pr_debug("%s: mipsnet_open\n", dev->name);

	err = request_irq(dev->irq, &mipsnet_interrupt,
			  IRQF_SHARED, dev->name, (void *) dev);

	if (err) {
		pr_debug("%s: %s(): can't get irq %d\n",
			 dev->name, __FUNCTION__, dev->irq);
		release_region(dev->base_addr, MIPSNET_IO_EXTENT);
		return err;
	}

	pr_debug("%s: %s(): got IO region at 0x%04lx and irq %d for dev.\n",
		 dev->name, __FUNCTION__, dev->base_addr, dev->irq);


	netif_start_queue(dev);

	/* test interrupt handler */
	outl(MIPSNET_INTCTL_TESTBIT,
	     mipsnet_reg_address(dev, interruptControl));


	return 0;
}

static int mipsnet_close(struct net_device *dev)
{
	pr_debug("%s: %s()\n", dev->name, __FUNCTION__);
	netif_stop_queue(dev);
	return 0;
}

static void mipsnet_set_mclist(struct net_device *dev)
{
}

static int __init mipsnet_probe(struct device *dev)
{
	struct net_device *netdev;
	int err;

	netdev = alloc_etherdev(0);
	if (!netdev) {
		err = -ENOMEM;
		goto out;
	}

	dev_set_drvdata(dev, netdev);

	netdev->open			= mipsnet_open;
	netdev->stop			= mipsnet_close;
	netdev->hard_start_xmit		= mipsnet_xmit;
	netdev->set_multicast_list	= mipsnet_set_mclist;

	/*
	 * TODO: probe for these or load them from PARAM
	 */
	netdev->base_addr = 0x4200;
	netdev->irq = MIPS_CPU_IRQ_BASE + MIPSCPU_INT_MB0 +
		      inl(mipsnet_reg_address(netdev, interruptInfo));

	/* Get the io region now, get irq on open() */
	if (!request_region(netdev->base_addr, MIPSNET_IO_EXTENT, "mipsnet")) {
		pr_debug("%s: %s(): IO region {start: 0x%04lux, len: %d} "
			 "for dev is not availble.\n", netdev->name,
			 __FUNCTION__, netdev->base_addr, MIPSNET_IO_EXTENT);
		err = -EBUSY;
		goto out_free_netdev;
	}

	/*
	 * Lacking any better mechanism to allocate a MAC address we use a
	 * random one ...
	 */
	random_ether_addr(netdev->dev_addr);

	err = register_netdev(netdev);
	if (err) {
		printk(KERN_ERR "MIPSNet: failed to register netdev.\n");
		goto out_free_region;
	}

	return 0;

out_free_region:
	release_region(netdev->base_addr, MIPSNET_IO_EXTENT);

out_free_netdev:
	free_netdev(netdev);

out:
	return err;
}

static int __devexit mipsnet_device_remove(struct device *device)
{
	struct net_device *dev = dev_get_drvdata(device);

	unregister_netdev(dev);
	release_region(dev->base_addr, MIPSNET_IO_EXTENT);
	free_netdev(dev);
	dev_set_drvdata(device, NULL);

	return 0;
}

static struct device_driver mipsnet_driver = {
	.name	= mipsnet_string,
	.bus	= &platform_bus_type,
	.probe	= mipsnet_probe,
	.remove	= __devexit_p(mipsnet_device_remove),
};

static int __init mipsnet_init_module(void)
{
	int err;

	printk(KERN_INFO "MIPSNet Ethernet driver. Version: %s. "
	       "(c)2005 MIPS Technologies, Inc.\n", MIPSNET_VERSION);

	err = driver_register(&mipsnet_driver);
	if (err)
		printk(KERN_ERR "Driver registration failed\n");

	return err;
}

static void __exit mipsnet_exit_module(void)
{
	pr_debug("MIPSNet Ethernet driver exiting\n");

	driver_unregister(&mipsnet_driver);
}

module_init(mipsnet_init_module);
module_exit(mipsnet_exit_module);
Commit	Line	Data
dcbf8477 RB	1	/*
	2	* This file is subject to the terms and conditions of the GNU General Public
	3	* License. See the file "COPYING" in the main directory of this archive
	4	* for more details.
	5	*/
	6
	7	#define DEBUG
	8
	9	#include <linux/init.h>
c2af68e5	10	#include <linux/io.h>
dcbf8477 RB	11	#include <linux/kernel.h>
	12	#include <linux/module.h>
	13	#include <linux/netdevice.h>
dcbf8477	14	#include <linux/etherdevice.h>
d052d1be	15	#include <linux/platform_device.h>
dcbf8477 RB	16	#include <asm/mips-boards/simint.h>
	17
	18	#include "mipsnet.h" /* actual device IO mapping */
	19
	20	#define MIPSNET_VERSION "2005-06-20"
	21
	22	#define mipsnet_reg_address(dev, field) (dev->base_addr + field_offset(field))
	23
dcbf8477 RB	24	static char mipsnet_string[] = "mipsnet";
	25
	26	/*
	27	* Copy data from the MIPSNET rx data port
	28	*/
	29	static int ioiocpy_frommipsnet(struct net_device dev, unsigned char kdata,
	30	int len)
	31	{
	32	uint32_t available_len = inl(mipsnet_reg_address(dev, rxDataCount));
	33	if (available_len < len)
	34	return -EFAULT;
	35
c2af68e5	36	for (; len > 0; len--, kdata++)
dcbf8477	37	*kdata = inb(mipsnet_reg_address(dev, rxDataBuffer));
dcbf8477 RB	38
	39	return inl(mipsnet_reg_address(dev, rxDataCount));
	40	}
	41
	42	static inline ssize_t mipsnet_put_todevice(struct net_device *dev,
	43	struct sk_buff *skb)
	44	{
	45	int count_to_go = skb->len;
	46	char *buf_ptr = skb->data;
dcbf8477 RB	47
dcbf8477 RB	48	pr_debug("%s: %s(): telling MIPSNET txDataCount(%d)\n",
c2af68e5	49	dev->name, __FUNCTION__, skb->len);
dcbf8477 RB	50
	51	outl(skb->len, mipsnet_reg_address(dev, txDataCount));
	52
	53	pr_debug("%s: %s(): sending data to MIPSNET txDataBuffer(%d)\n",
c2af68e5	54	dev->name, __FUNCTION__, skb->len);
dcbf8477	55
c2af68e5	56	for (; count_to_go; buf_ptr++, count_to_go--)
dcbf8477	57	outb(*buf_ptr, mipsnet_reg_address(dev, txDataBuffer));
dcbf8477	58
09f75cd7 JG	59	dev->stats.tx_packets++;
09f75cd7 JG	60	dev->stats.tx_bytes += skb->len;
dcbf8477 RB	61
	62	return skb->len;
	63	}
	64
	65	static int mipsnet_xmit(struct sk_buff skb, struct net_device dev)
	66	{
	67	pr_debug("%s:%s(): transmitting %d bytes\n",
c2af68e5	68	dev->name, __FUNCTION__, skb->len);
dcbf8477 RB	69
	70	/* Only one packet at a time. Once TXDONE interrupt is serviced, the
	71	* queue will be restarted.
	72	*/
	73	netif_stop_queue(dev);
	74	mipsnet_put_todevice(dev, skb);
	75
	76	return 0;
	77	}
	78
	79	static inline ssize_t mipsnet_get_fromdev(struct net_device *dev, size_t count)
	80	{
	81	struct sk_buff *skb;
	82	size_t len = count;
dcbf8477	83
c2af68e5 RB	84	skb = alloc_skb(len + 2, GFP_KERNEL);
c2af68e5 RB	85	if (!skb) {
09f75cd7	86	dev->stats.rx_dropped++;
dcbf8477 RB	87	return -ENOMEM;
	88	}
	89
	90	skb_reserve(skb, 2);
	91	if (ioiocpy_frommipsnet(dev, skb_put(skb, len), len))
	92	return -EFAULT;
	93
dcbf8477 RB	94	skb->protocol = eth_type_trans(skb, dev);
	95	skb->ip_summed = CHECKSUM_UNNECESSARY;
	96
	97	pr_debug("%s:%s(): pushing RXed data to kernel\n",
c2af68e5	98	dev->name, __FUNCTION__);
dcbf8477 RB	99	netif_rx(skb);
dcbf8477 RB	100
09f75cd7 JG	101	dev->stats.rx_packets++;
09f75cd7 JG	102	dev->stats.rx_bytes += len;
dcbf8477 RB	103
	104	return count;
	105	}
	106
7d12e780	107	static irqreturn_t mipsnet_interrupt(int irq, void *dev_id)
dcbf8477 RB	108	{
	109	struct net_device *dev = dev_id;
	110
	111	irqreturn_t retval = IRQ_NONE;
	112	uint64_t interruptFlags;
	113
	114	if (irq == dev->irq) {
	115	pr_debug("%s:%s(): irq %d for device\n",
c2af68e5	116	dev->name, __FUNCTION__, irq);
dcbf8477 RB	117
	118	retval = IRQ_HANDLED;
	119
	120	interruptFlags =
	121	inl(mipsnet_reg_address(dev, interruptControl));
	122	pr_debug("%s:%s(): intCtl=0x%016llx\n", dev->name,
c2af68e5	123	__FUNCTION__, interruptFlags);
dcbf8477 RB	124
	125	if (interruptFlags & MIPSNET_INTCTL_TXDONE) {
	126	pr_debug("%s:%s(): got TXDone\n",
c2af68e5	127	dev->name, __FUNCTION__);
dcbf8477 RB	128	outl(MIPSNET_INTCTL_TXDONE,
dcbf8477 RB	129	mipsnet_reg_address(dev, interruptControl));
c2af68e5	130	/* only one packet at a time, we are done. */
dcbf8477 RB	131	netif_wake_queue(dev);
	132	} else if (interruptFlags & MIPSNET_INTCTL_RXDONE) {
	133	pr_debug("%s:%s(): got RX data\n",
c2af68e5	134	dev->name, __FUNCTION__);
dcbf8477	135	mipsnet_get_fromdev(dev,
c2af68e5	136	inl(mipsnet_reg_address(dev, rxDataCount)));
dcbf8477	137	pr_debug("%s:%s(): clearing RX int\n",
c2af68e5	138	dev->name, __FUNCTION__);
dcbf8477 RB	139	outl(MIPSNET_INTCTL_RXDONE,
	140	mipsnet_reg_address(dev, interruptControl));
	141
	142	} else if (interruptFlags & MIPSNET_INTCTL_TESTBIT) {
	143	pr_debug("%s:%s(): got test interrupt\n",
c2af68e5 RB	144	dev->name, __FUNCTION__);
	145	/*
	146	* TESTBIT is cleared on read.
	147	* And takes effect after a write with 0
	148	*/
dcbf8477 RB	149	outl(0, mipsnet_reg_address(dev, interruptControl));
	150	} else {
	151	pr_debug("%s:%s(): no valid fags 0x%016llx\n",
c2af68e5 RB	152	dev->name, __FUNCTION__, interruptFlags);
c2af68e5 RB	153	/* Maybe shared IRQ, just ignore, no clearing. */
dcbf8477 RB	154	retval = IRQ_NONE;
	155	}
	156
	157	} else {
	158	printk(KERN_INFO "%s: %s(): irq %d for unknown device\n",
	159	dev->name, __FUNCTION__, irq);
	160	retval = IRQ_NONE;
	161	}
	162	return retval;
c2af68e5	163	}
dcbf8477 RB	164
	165	static int mipsnet_open(struct net_device *dev)
	166	{
	167	int err;
	168	pr_debug("%s: mipsnet_open\n", dev->name);
	169
	170	err = request_irq(dev->irq, &mipsnet_interrupt,
1fb9df5d	171	IRQF_SHARED, dev->name, (void *) dev);
dcbf8477 RB	172
	173	if (err) {
	174	pr_debug("%s: %s(): can't get irq %d\n",
c2af68e5	175	dev->name, __FUNCTION__, dev->irq);
dcbf8477 RB	176	release_region(dev->base_addr, MIPSNET_IO_EXTENT);
	177	return err;
	178	}
	179
	180	pr_debug("%s: %s(): got IO region at 0x%04lx and irq %d for dev.\n",
c2af68e5	181	dev->name, __FUNCTION__, dev->base_addr, dev->irq);
dcbf8477 RB	182
	183
	184	netif_start_queue(dev);
	185
c2af68e5	186	/* test interrupt handler */
dcbf8477 RB	187	outl(MIPSNET_INTCTL_TESTBIT,
	188	mipsnet_reg_address(dev, interruptControl));
	189
	190
	191	return 0;
	192	}
	193
	194	static int mipsnet_close(struct net_device *dev)
	195	{
	196	pr_debug("%s: %s()\n", dev->name, __FUNCTION__);
	197	netif_stop_queue(dev);
	198	return 0;
	199	}
	200
dcbf8477 RB	201	static void mipsnet_set_mclist(struct net_device *dev)
dcbf8477 RB	202	{
dcbf8477 RB	203	}
	204
	205	static int __init mipsnet_probe(struct device *dev)
	206	{
	207	struct net_device *netdev;
	208	int err;
	209
09f75cd7	210	netdev = alloc_etherdev(0);
dcbf8477 RB	211	if (!netdev) {
	212	err = -ENOMEM;
	213	goto out;
	214	}
	215
	216	dev_set_drvdata(dev, netdev);
	217
	218	netdev->open = mipsnet_open;
	219	netdev->stop = mipsnet_close;
	220	netdev->hard_start_xmit = mipsnet_xmit;
dcbf8477 RB	221	netdev->set_multicast_list = mipsnet_set_mclist;
	222
	223	/*
	224	* TODO: probe for these or load them from PARAM
	225	*/
	226	netdev->base_addr = 0x4200;
3b1d4ed5	227	netdev->irq = MIPS_CPU_IRQ_BASE + MIPSCPU_INT_MB0 +
c2af68e5	228	inl(mipsnet_reg_address(netdev, interruptInfo));
dcbf8477	229
c2af68e5	230	/* Get the io region now, get irq on open() */
dcbf8477 RB	231	if (!request_region(netdev->base_addr, MIPSNET_IO_EXTENT, "mipsnet")) {
dcbf8477 RB	232	pr_debug("%s: %s(): IO region {start: 0x%04lux, len: %d} "
c2af68e5 RB	233	"for dev is not availble.\n", netdev->name,
c2af68e5 RB	234	__FUNCTION__, netdev->base_addr, MIPSNET_IO_EXTENT);
dcbf8477 RB	235	err = -EBUSY;
	236	goto out_free_netdev;
	237	}
	238
	239	/*
	240	* Lacking any better mechanism to allocate a MAC address we use a
	241	* random one ...
	242	*/
	243	random_ether_addr(netdev->dev_addr);
	244
	245	err = register_netdev(netdev);
	246	if (err) {
	247	printk(KERN_ERR "MIPSNet: failed to register netdev.\n");
	248	goto out_free_region;
	249	}
	250
	251	return 0;
	252
	253	out_free_region:
	254	release_region(netdev->base_addr, MIPSNET_IO_EXTENT);
	255
	256	out_free_netdev:
	257	free_netdev(netdev);
	258
	259	out:
	260	return err;
	261	}
	262
	263	static int __devexit mipsnet_device_remove(struct device *device)
	264	{
	265	struct net_device *dev = dev_get_drvdata(device);
	266
	267	unregister_netdev(dev);
	268	release_region(dev->base_addr, MIPSNET_IO_EXTENT);
	269	free_netdev(dev);
	270	dev_set_drvdata(device, NULL);
	271
	272	return 0;
	273	}
	274
	275	static struct device_driver mipsnet_driver = {
	276	.name = mipsnet_string,
	277	.bus = &platform_bus_type,
	278	.probe = mipsnet_probe,
	279	.remove = __devexit_p(mipsnet_device_remove),
	280	};
	281
dcbf8477 RB	282	static int __init mipsnet_init_module(void)
dcbf8477 RB	283	{
dcbf8477 RB	284	int err;
	285
	286	printk(KERN_INFO "MIPSNet Ethernet driver. Version: %s. "
	287	"(c)2005 MIPS Technologies, Inc.\n", MIPSNET_VERSION);
	288
1e2b980f RB	289	err = driver_register(&mipsnet_driver);
1e2b980f RB	290	if (err)
dcbf8477	291	printk(KERN_ERR "Driver registration failed\n");
dcbf8477	292
dcbf8477 RB	293	return err;
	294	}
	295
	296	static void __exit mipsnet_exit_module(void)
	297	{
	298	pr_debug("MIPSNet Ethernet driver exiting\n");
	299
	300	driver_unregister(&mipsnet_driver);
	301	}
	302
	303	module_init(mipsnet_init_module);
	304	module_exit(mipsnet_exit_module);