[GitHub/mt8127/android_kernel_alcatel_ttab.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/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->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);
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>
	10	#include <linux/kernel.h>
	11	#include <linux/module.h>
	12	#include <linux/netdevice.h>
dcbf8477 RB	13	#include <linux/etherdevice.h>
dcbf8477 RB	14	#include <linux/netdevice.h>
d052d1be	15	#include <linux/platform_device.h>
dcbf8477 RB	16	#include <asm/io.h>
	17	#include <asm/mips-boards/simint.h>
	18
	19	#include "mipsnet.h" /* actual device IO mapping */
	20
	21	#define MIPSNET_VERSION "2005-06-20"
	22
	23	#define mipsnet_reg_address(dev, field) (dev->base_addr + field_offset(field))
	24
	25	struct mipsnet_priv {
	26	struct net_device_stats stats;
	27	};
	28
	29	static struct platform_device *mips_plat_dev;
	30
	31	static char mipsnet_string[] = "mipsnet";
	32
	33	/*
	34	* Copy data from the MIPSNET rx data port
	35	*/
	36	static int ioiocpy_frommipsnet(struct net_device dev, unsigned char kdata,
	37	int len)
	38	{
	39	uint32_t available_len = inl(mipsnet_reg_address(dev, rxDataCount));
	40	if (available_len < len)
	41	return -EFAULT;
	42
	43	for (; len > 0; len--, kdata++) {
	44	*kdata = inb(mipsnet_reg_address(dev, rxDataBuffer));
	45	}
	46
	47	return inl(mipsnet_reg_address(dev, rxDataCount));
	48	}
	49
	50	static inline ssize_t mipsnet_put_todevice(struct net_device *dev,
	51	struct sk_buff *skb)
	52	{
	53	int count_to_go = skb->len;
	54	char *buf_ptr = skb->data;
	55	struct mipsnet_priv *mp = netdev_priv(dev);
	56
	57	pr_debug("%s: %s(): telling MIPSNET txDataCount(%d)\n",
	58	dev->name, __FUNCTION__, skb->len);
	59
	60	outl(skb->len, mipsnet_reg_address(dev, txDataCount));
	61
	62	pr_debug("%s: %s(): sending data to MIPSNET txDataBuffer(%d)\n",
	63	dev->name, __FUNCTION__, skb->len);
	64
	65	for (; count_to_go; buf_ptr++, count_to_go--) {
	66	outb(*buf_ptr, mipsnet_reg_address(dev, txDataBuffer));
	67	}
	68
	69	mp->stats.tx_packets++;
	70	mp->stats.tx_bytes += skb->len;
	71
	72	return skb->len;
	73	}
	74
	75	static int mipsnet_xmit(struct sk_buff skb, struct net_device dev)
	76	{
	77	pr_debug("%s:%s(): transmitting %d bytes\n",
	78	dev->name, __FUNCTION__, skb->len);
	79
80	/* Only one packet at a time. Once TXDONE interrupt is serviced, the
81	* queue will be restarted.
82	*/
83	netif_stop_queue(dev);
84	mipsnet_put_todevice(dev, skb);
85
86	return 0;
87	}
88
89	static inline ssize_t mipsnet_get_fromdev(struct net_device *dev, size_t count)
90	{
91	struct sk_buff *skb;
92	size_t len = count;
93	struct mipsnet_priv *mp = netdev_priv(dev);
94
95	if (!(skb = alloc_skb(len + 2, GFP_KERNEL))) {
96	mp->stats.rx_dropped++;
97	return -ENOMEM;
98	}
99
100	skb_reserve(skb, 2);
101	if (ioiocpy_frommipsnet(dev, skb_put(skb, len), len))
102	return -EFAULT;
103
dcbf8477 RB	104	skb->protocol = eth_type_trans(skb, dev);
	105	skb->ip_summed = CHECKSUM_UNNECESSARY;
	106
	107	pr_debug("%s:%s(): pushing RXed data to kernel\n",
	108	dev->name, __FUNCTION__);
	109	netif_rx(skb);
	110
	111	mp->stats.rx_packets++;
	112	mp->stats.rx_bytes += len;
	113
	114	return count;
	115	}
	116
7d12e780	117	static irqreturn_t mipsnet_interrupt(int irq, void *dev_id)
dcbf8477 RB	118	{
	119	struct net_device *dev = dev_id;
	120
	121	irqreturn_t retval = IRQ_NONE;
	122	uint64_t interruptFlags;
	123
	124	if (irq == dev->irq) {
	125	pr_debug("%s:%s(): irq %d for device\n",
	126	dev->name, __FUNCTION__, irq);
	127
	128	retval = IRQ_HANDLED;
	129
	130	interruptFlags =
	131	inl(mipsnet_reg_address(dev, interruptControl));
	132	pr_debug("%s:%s(): intCtl=0x%016llx\n", dev->name,
	133	__FUNCTION__, interruptFlags);
	134
	135	if (interruptFlags & MIPSNET_INTCTL_TXDONE) {
	136	pr_debug("%s:%s(): got TXDone\n",
	137	dev->name, __FUNCTION__);
	138	outl(MIPSNET_INTCTL_TXDONE,
	139	mipsnet_reg_address(dev, interruptControl));
	140	// only one packet at a time, we are done.
	141	netif_wake_queue(dev);
	142	} else if (interruptFlags & MIPSNET_INTCTL_RXDONE) {
	143	pr_debug("%s:%s(): got RX data\n",
	144	dev->name, __FUNCTION__);
	145	mipsnet_get_fromdev(dev,
	146	inl(mipsnet_reg_address(dev, rxDataCount)));
	147	pr_debug("%s:%s(): clearing RX int\n",
	148	dev->name, __FUNCTION__);
	149	outl(MIPSNET_INTCTL_RXDONE,
	150	mipsnet_reg_address(dev, interruptControl));
	151
	152	} else if (interruptFlags & MIPSNET_INTCTL_TESTBIT) {
	153	pr_debug("%s:%s(): got test interrupt\n",
	154	dev->name, __FUNCTION__);
	155	// TESTBIT is cleared on read.
	156	// And takes effect after a write with 0
	157	outl(0, mipsnet_reg_address(dev, interruptControl));
	158	} else {
	159	pr_debug("%s:%s(): no valid fags 0x%016llx\n",
	160	dev->name, __FUNCTION__, interruptFlags);
	161	// Maybe shared IRQ, just ignore, no clearing.
	162	retval = IRQ_NONE;
	163	}
	164
	165	} else {
	166	printk(KERN_INFO "%s: %s(): irq %d for unknown device\n",
	167	dev->name, __FUNCTION__, irq);
	168	retval = IRQ_NONE;
	169	}
	170	return retval;
	171	} //mipsnet_interrupt()
	172
	173	static int mipsnet_open(struct net_device *dev)
	174	{
	175	int err;
	176	pr_debug("%s: mipsnet_open\n", dev->name);
	177
	178	err = request_irq(dev->irq, &mipsnet_interrupt,
1fb9df5d	179	IRQF_SHARED, dev->name, (void *) dev);
dcbf8477 RB	180
	181	if (err) {
	182	pr_debug("%s: %s(): can't get irq %d\n",
	183	dev->name, __FUNCTION__, dev->irq);
	184	release_region(dev->base_addr, MIPSNET_IO_EXTENT);
	185	return err;
	186	}
	187
	188	pr_debug("%s: %s(): got IO region at 0x%04lx and irq %d for dev.\n",
	189	dev->name, __FUNCTION__, dev->base_addr, dev->irq);
	190
	191
	192	netif_start_queue(dev);
	193
	194	// test interrupt handler
	195	outl(MIPSNET_INTCTL_TESTBIT,
	196	mipsnet_reg_address(dev, interruptControl));
	197
	198
	199	return 0;
	200	}
	201
	202	static int mipsnet_close(struct net_device *dev)
	203	{
	204	pr_debug("%s: %s()\n", dev->name, __FUNCTION__);
	205	netif_stop_queue(dev);
	206	return 0;
	207	}
	208
	209	static struct net_device_stats mipsnet_get_stats(struct net_device dev)
	210	{
	211	struct mipsnet_priv *mp = netdev_priv(dev);
	212
	213	return &mp->stats;
	214	}
	215
	216	static void mipsnet_set_mclist(struct net_device *dev)
	217	{
	218	// we don't do anything
	219	return;
	220	}
	221
	222	static int __init mipsnet_probe(struct device *dev)
	223	{
	224	struct net_device *netdev;
	225	int err;
	226
	227	netdev = alloc_etherdev(sizeof(struct mipsnet_priv));
	228	if (!netdev) {
	229	err = -ENOMEM;
	230	goto out;
	231	}
	232
	233	dev_set_drvdata(dev, netdev);
	234
	235	netdev->open = mipsnet_open;
	236	netdev->stop = mipsnet_close;
	237	netdev->hard_start_xmit = mipsnet_xmit;
	238	netdev->get_stats = mipsnet_get_stats;
	239	netdev->set_multicast_list = mipsnet_set_mclist;
	240
	241	/*
	242	* TODO: probe for these or load them from PARAM
	243	*/
244	netdev->base_addr = 0x4200;
245	netdev->irq = MIPSCPU_INT_BASE + MIPSCPU_INT_MB0 +
246	inl(mipsnet_reg_address(netdev, interruptInfo));
247
248	// Get the io region now, get irq on open()
249	if (!request_region(netdev->base_addr, MIPSNET_IO_EXTENT, "mipsnet")) {
250	pr_debug("%s: %s(): IO region {start: 0x%04lux, len: %d} "
251	"for dev is not availble.\n", netdev->name,
252	__FUNCTION__, netdev->base_addr, MIPSNET_IO_EXTENT);
253	err = -EBUSY;
254	goto out_free_netdev;
255	}
256
257	/*
258	* Lacking any better mechanism to allocate a MAC address we use a
259	* random one ...
260	*/
261	random_ether_addr(netdev->dev_addr);
262
263	err = register_netdev(netdev);
264	if (err) {
265	printk(KERN_ERR "MIPSNet: failed to register netdev.\n");
266	goto out_free_region;
267	}
268
269	return 0;
270
271	out_free_region:
272	release_region(netdev->base_addr, MIPSNET_IO_EXTENT);
273
274	out_free_netdev:
275	free_netdev(netdev);
276
277	out:
278	return err;
279	}
280
281	static int __devexit mipsnet_device_remove(struct device *device)
282	{
283	struct net_device *dev = dev_get_drvdata(device);
284
285	unregister_netdev(dev);
286	release_region(dev->base_addr, MIPSNET_IO_EXTENT);
287	free_netdev(dev);
288	dev_set_drvdata(device, NULL);
289
290	return 0;
291	}
292
293	static struct device_driver mipsnet_driver = {
294	.name = mipsnet_string,
295	.bus = &platform_bus_type,
296	.probe = mipsnet_probe,
297	.remove = __devexit_p(mipsnet_device_remove),
298	};
299
300	static void mipsnet_platform_release(struct device *device)
301	{
302	struct platform_device *pldev;
303
304	/* free device */
305	pldev = to_platform_device(device);
306	kfree(pldev);
307	}
308
309	static int __init mipsnet_init_module(void)
310	{
311	struct platform_device *pldev;
312	int err;
313
314	printk(KERN_INFO "MIPSNet Ethernet driver. Version: %s. "
315	"(c)2005 MIPS Technologies, Inc.\n", MIPSNET_VERSION);
316
317	if (driver_register(&mipsnet_driver)) {
318	printk(KERN_ERR "Driver registration failed\n");
319	err = -ENODEV;
320	goto out;
321	}
322
323	if (!(pldev = kmalloc (sizeof (*pldev), GFP_KERNEL))) {
324	err = -ENOMEM;
325	goto out_unregister_driver;
326	}
327
328	memset (pldev, 0, sizeof (*pldev));
329	pldev->name = mipsnet_string;
330	pldev->id = 0;
331	pldev->dev.release = mipsnet_platform_release;
332
333	if (platform_device_register(pldev)) {
334	err = -ENODEV;
335	goto out_free_pldev;
336	}
337
338	if (!pldev->dev.driver) {
339	/*
340	* The driver was not bound to this device, there was
341	* no hardware at this address. Unregister it, as the
342	* release fuction will take care of freeing the
343	* allocated structure
344	*/
345	platform_device_unregister (pldev);
346	}
347
348	mips_plat_dev = pldev;
349
350	return 0;
351
352	out_free_pldev:
353	kfree(pldev);
354
355	out_unregister_driver:
356	driver_unregister(&mipsnet_driver);
357	out:
358	return err;
359	}
360
361	static void __exit mipsnet_exit_module(void)
362	{
363	pr_debug("MIPSNet Ethernet driver exiting\n");
364
365	driver_unregister(&mipsnet_driver);
366	}
367
368	module_init(mipsnet_init_module);
369	module_exit(mipsnet_exit_module);