/* * 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/kernel.h>#include <linux/module.h>#include <linux/netdevice.h>#include <linux/etherdevice.h>#include <linux/netdevice.h>#include <linux/platform_device.h>#include <asm/io.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)) struct mipsnet_priv {	struct net_device_stats stats;}; static struct platform_device *mips_plat_dev; 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;	struct mipsnet_priv *mp = netdev_priv(dev); 	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));	} 	mp->stats.tx_packets++;	mp->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;	struct mipsnet_priv *mp = netdev_priv(dev); 	if (!(skb = alloc_skb(len + 2, GFP_KERNEL))) {		mp->stats.rx_dropped++;		return -ENOMEM;	} 	skb_reserve(skb, 2);	if (ioiocpy_frommipsnet(dev, skb_put(skb, len), len))		return -EFAULT; 	skb->dev = dev;	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); 	mp->stats.rx_packets++;	mp->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;}				//mipsnet_interrupt() 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 struct net_device_stats *mipsnet_get_stats(struct net_device *dev){	struct mipsnet_priv *mp = netdev_priv(dev); 	return &mp->stats;} static void mipsnet_set_mclist(struct net_device *dev){	// we don't do anything	return;} static int __init mipsnet_probe(struct device *dev){	struct net_device *netdev;	int err; 	netdev = alloc_etherdev(sizeof(struct mipsnet_priv));	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->get_stats		= mipsnet_get_stats;	netdev->set_multicast_list	= mipsnet_set_mclist; 	/*	 * TODO: probe for these or load them from PARAM	 */	netdev->base_addr = 0x4200;	netdev->irq = MIPSCPU_INT_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 void mipsnet_platform_release(struct device *device){	struct platform_device *pldev; 	/* free device */	pldev = to_platform_device(device);	kfree(pldev);} static int __init mipsnet_init_module(void){	struct platform_device *pldev;	int err; 	printk(KERN_INFO "MIPSNet Ethernet driver. Version: %s. "	       "(c)2005 MIPS Technologies, Inc.\n", MIPSNET_VERSION); 	if (driver_register(&mipsnet_driver)) {		printk(KERN_ERR "Driver registration failed\n");		err = -ENODEV;		goto out;	}         if (!(pldev = kmalloc (sizeof (*pldev), GFP_KERNEL))) {		err = -ENOMEM;		goto out_unregister_driver;	} 	memset (pldev, 0, sizeof (*pldev));	pldev->name		= mipsnet_string;	pldev->id		= 0;	pldev->dev.release	= mipsnet_platform_release; 	if (platform_device_register(pldev)) {		err = -ENODEV;		goto out_free_pldev;	}         if (!pldev->dev.driver) {		/*		 * The driver was not bound to this device, there was                 * no hardware at this address. Unregister it, as the		 * release fuction will take care of freeing the		 * allocated structure		 */		platform_device_unregister (pldev);	} 	mips_plat_dev		= pldev; 	return 0; out_free_pldev:	kfree(pldev); out_unregister_driver:	driver_unregister(&mipsnet_driver);out:	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);