[net-next-2.6.git] / drivers / net / es3210.c

/*
	es3210.c

	Linux driver for Racal-Interlan ES3210 EISA Network Adapter

	Copyright (C) 1996, Paul Gortmaker.

	This software may be used and distributed according to the terms
	of the GNU General Public License, incorporated herein by reference.

	Information and Code Sources:

	1) The existing myriad of Linux 8390 drivers written by Donald Becker.

	2) Once again Russ Nelson's asm packet driver provided additional info.

	3) Info for getting IRQ and sh-mem gleaned from the EISA cfg files.
	   Too bad it doesn't work -- see below.

	The ES3210 is an EISA shared memory NS8390 implementation. Note
	that all memory copies to/from the board must be 32bit transfers.
	Which rules out using eth_io_copy_and_sum() in this driver.

	Apparently there are two slightly different revisions of the
	card, since there are two distinct EISA cfg files (!rii0101.cfg
	and !rii0102.cfg) One has media select in the cfg file and the
	other doesn't. Hopefully this will work with either.

	That is about all I can tell you about it, having never actually
	even seen one of these cards. :)  Try http://www.interlan.com
	if you want more info.

	Thanks go to Mark Salazar for testing v0.02 of this driver.

	Bugs, to-fix, etc:

	1) The EISA cfg ports that are *supposed* to have the IRQ and shared
	   mem values just read 0xff all the time. Hrrmpf. Apparently the
	   same happens with the packet driver as the code for reading
	   these registers is disabled there. In the meantime, boot with:
	   ether=<IRQ>,0,0x<shared_mem_addr>,eth0 to override the IRQ and
	   shared memory detection. (The i/o port detection is okay.)

	2) Module support currently untested. Probably works though.

*/

static const char version[] =
	"es3210.c: Driver revision v0.03, 14/09/96\n";

#include <linux/module.h>
#include <linux/eisa.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>

#include <asm/io.h>
#include <asm/system.h>

#include "8390.h"

static int es_probe1(struct net_device *dev, int ioaddr);

static void es_reset_8390(struct net_device *dev);

static void es_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page);
static void es_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset);
static void es_block_output(struct net_device *dev, int count, const unsigned char *buf, int start_page);

#define ES_START_PG	0x00    /* First page of TX buffer		*/
#define ES_STOP_PG	0x40    /* Last page +1 of RX ring		*/

#define ES_IO_EXTENT	0x37	/* The cfg file says 0xc90 -> 0xcc7	*/
#define ES_ID_PORT	0xc80	/* Same for all EISA cards 		*/
#define ES_SA_PROM	0xc90	/* Start of e'net addr.			*/
#define ES_RESET_PORT	0xc84	/* From the packet driver source	*/
#define ES_NIC_OFFSET	0xca0	/* Hello, the 8390 is *here*		*/

#define ES_ADDR0	0x02	/* 3 byte vendor prefix			*/
#define ES_ADDR1	0x07
#define ES_ADDR2	0x01

/*
 * Two card revisions. EISA ID's are always rev. minor, rev. major,, and
 * then the three vendor letters stored in 5 bits each, with an "a" = 1.
 * For eg: "rii" = 10010 01001 01001 = 0x4929, which is how the EISA
 * config utility determines automagically what config file(s) to use.
 */
#define ES_EISA_ID1	0x01012949	/* !rii0101.cfg 		*/
#define ES_EISA_ID2	0x02012949	/* !rii0102.cfg 		*/

#define ES_CFG1		0xcc0	/* IOPORT(1) --> IOPORT(6) in cfg file	*/
#define ES_CFG2		0xcc1
#define ES_CFG3		0xcc2
#define ES_CFG4		0xcc3
#define ES_CFG5		0xcc4
#define ES_CFG6		0xc84	/* NB: 0xc84 is also "reset" port.	*/

/*
 *	You can OR any of the following bits together and assign it
 *	to ES_DEBUG to get verbose driver info during operation.
 *	Some of these don't do anything yet.
 */

#define ES_D_PROBE	0x01
#define ES_D_RX_PKT	0x02
#define ES_D_TX_PKT	0x04
#define ED_D_IRQ	0x08

#define ES_DEBUG	0

static unsigned char lo_irq_map[] __initdata = {3, 4, 5, 6, 7, 9, 10};
static unsigned char hi_irq_map[] __initdata = {11, 12, 0, 14, 0, 0, 0, 15};

/*
 *	Probe for the card. The best way is to read the EISA ID if it
 *	is known. Then we check the prefix of the station address
 *	PROM for a match against the Racal-Interlan assigned value.
 */

static int __init do_es_probe(struct net_device *dev)
{
	unsigned short ioaddr = dev->base_addr;
	int irq = dev->irq;
	int mem_start = dev->mem_start;

	if (ioaddr > 0x1ff)		/* Check a single specified location. */
		return es_probe1(dev, ioaddr);
	else if (ioaddr > 0)		/* Don't probe at all. */
		return -ENXIO;

	if (!EISA_bus) {
#if ES_DEBUG & ES_D_PROBE
		printk("es3210.c: Not EISA bus. Not probing high ports.\n");
#endif
		return -ENXIO;
	}

	/* EISA spec allows for up to 16 slots, but 8 is typical. */
	for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
		if (es_probe1(dev, ioaddr) == 0)
			return 0;
		dev->irq = irq;
		dev->mem_start = mem_start;
	}

	return -ENODEV;
}

#ifndef MODULE
struct net_device * __init es_probe(int unit)
{
	struct net_device *dev = alloc_ei_netdev();
	int err;

	if (!dev)
		return ERR_PTR(-ENOMEM);

	sprintf(dev->name, "eth%d", unit);
	netdev_boot_setup_check(dev);

	err = do_es_probe(dev);
	if (err)
		goto out;
	return dev;
out:
	free_netdev(dev);
	return ERR_PTR(err);
}
#endif

static int __init es_probe1(struct net_device *dev, int ioaddr)
{
	int i, retval;
	unsigned long eisa_id;

	if (!request_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT, "es3210"))
		return -ENODEV;

#if ES_DEBUG & ES_D_PROBE
	printk("es3210.c: probe at %#x, ID %#8x\n", ioaddr, inl(ioaddr + ES_ID_PORT));
	printk("es3210.c: config regs: %#x %#x %#x %#x %#x %#x\n",
		inb(ioaddr + ES_CFG1), inb(ioaddr + ES_CFG2), inb(ioaddr + ES_CFG3),
		inb(ioaddr + ES_CFG4), inb(ioaddr + ES_CFG5), inb(ioaddr + ES_CFG6));
#endif

/*	Check the EISA ID of the card. */
	eisa_id = inl(ioaddr + ES_ID_PORT);
	if ((eisa_id != ES_EISA_ID1) && (eisa_id != ES_EISA_ID2)) {
		retval = -ENODEV;
		goto out;
	}

	for (i = 0; i < ETHER_ADDR_LEN ; i++)
		dev->dev_addr[i] = inb(ioaddr + ES_SA_PROM + i);

/*	Check the Racal vendor ID as well. */
	if (dev->dev_addr[0] != ES_ADDR0 ||
	    dev->dev_addr[1] != ES_ADDR1 ||
	    dev->dev_addr[2] != ES_ADDR2) {
		printk("es3210.c: card not found %pM (invalid_prefix).\n",
		       dev->dev_addr);
		retval = -ENODEV;
		goto out;
	}

	printk("es3210.c: ES3210 rev. %ld at %#x, node %pM",
	       eisa_id>>24, ioaddr, dev->dev_addr);

	/* Snarf the interrupt now. */
	if (dev->irq == 0) {
		unsigned char hi_irq = inb(ioaddr + ES_CFG2) & 0x07;
		unsigned char lo_irq = inb(ioaddr + ES_CFG1) & 0xfe;

		if (hi_irq != 0) {
			dev->irq = hi_irq_map[hi_irq - 1];
		} else {
			int i = 0;
			while (lo_irq > (1<<i)) i++;
			dev->irq = lo_irq_map[i];
		}
		printk(" using IRQ %d", dev->irq);
#if ES_DEBUG & ES_D_PROBE
		printk("es3210.c: hi_irq %#x, lo_irq %#x, dev->irq = %d\n",
					hi_irq, lo_irq, dev->irq);
#endif
	} else {
		if (dev->irq == 2)
			dev->irq = 9;			/* Doh! */
		printk(" assigning IRQ %d", dev->irq);
	}

	if (request_irq(dev->irq, ei_interrupt, 0, "es3210", dev)) {
		printk (" unable to get IRQ %d.\n", dev->irq);
		retval = -EAGAIN;
		goto out;
	}

	if (dev->mem_start == 0) {
		unsigned char mem_enabled = inb(ioaddr + ES_CFG2) & 0xc0;
		unsigned char mem_bits = inb(ioaddr + ES_CFG3) & 0x07;

		if (mem_enabled != 0x80) {
			printk(" shared mem disabled - giving up\n");
			retval = -ENXIO;
			goto out1;
		}
		dev->mem_start = 0xC0000 + mem_bits*0x4000;
		printk(" using ");
	} else {
		printk(" assigning ");
	}

	ei_status.mem = ioremap(dev->mem_start, (ES_STOP_PG - ES_START_PG)*256);
	if (!ei_status.mem) {
		printk("ioremap failed - giving up\n");
		retval = -ENXIO;
		goto out1;
	}

	dev->mem_end = dev->mem_start + (ES_STOP_PG - ES_START_PG)*256;

	printk("mem %#lx-%#lx\n", dev->mem_start, dev->mem_end-1);

#if ES_DEBUG & ES_D_PROBE
	if (inb(ioaddr + ES_CFG5))
		printk("es3210: Warning - DMA channel enabled, but not used here.\n");
#endif
	/* Note, point at the 8390, and not the card... */
	dev->base_addr = ioaddr + ES_NIC_OFFSET;

	ei_status.name = "ES3210";
	ei_status.tx_start_page = ES_START_PG;
	ei_status.rx_start_page = ES_START_PG + TX_PAGES;
	ei_status.stop_page = ES_STOP_PG;
	ei_status.word16 = 1;

	if (ei_debug > 0)
		printk(version);

	ei_status.reset_8390 = &es_reset_8390;
	ei_status.block_input = &es_block_input;
	ei_status.block_output = &es_block_output;
	ei_status.get_8390_hdr = &es_get_8390_hdr;

	dev->netdev_ops = &ei_netdev_ops;
	NS8390_init(dev, 0);

	retval = register_netdev(dev);
	if (retval)
		goto out1;
	return 0;
out1:
	free_irq(dev->irq, dev);
out:
	release_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT);
	return retval;
}

/*
 *	Reset as per the packet driver method. Judging by the EISA cfg
 *	file, this just toggles the "Board Enable" bits (bit 2 and 0).
 */

static void es_reset_8390(struct net_device *dev)
{
	unsigned short ioaddr = dev->base_addr;
	unsigned long end;

	outb(0x04, ioaddr + ES_RESET_PORT);
	if (ei_debug > 1) printk("%s: resetting the ES3210...", dev->name);

	end = jiffies + 2*HZ/100;
        while ((signed)(end - jiffies) > 0) continue;

	ei_status.txing = 0;
	outb(0x01, ioaddr + ES_RESET_PORT);
	if (ei_debug > 1) printk("reset done\n");
}

/*
 *	Note: In the following three functions is the implicit assumption
 *	that the associated memcpy will only use "rep; movsl" as long as
 *	we keep the counts as some multiple of doublewords. This is a
 *	requirement of the hardware, and also prevents us from using
 *	eth_io_copy_and_sum() since we can't guarantee it will limit
 *	itself to doubleword access.
 */

/*
 *	Grab the 8390 specific header. Similar to the block_input routine, but
 *	we don't need to be concerned with ring wrap as the header will be at
 *	the start of a page, so we optimize accordingly. (A single doubleword.)
 */

static void
es_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
{
	void __iomem *hdr_start = ei_status.mem + ((ring_page - ES_START_PG)<<8);
	memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
	hdr->count = (hdr->count + 3) & ~3;     /* Round up allocation. */
}

/*
 *	Block input and output are easy on shared memory ethercards, the only
 *	complication is when the ring buffer wraps. The count will already
 *	be rounded up to a doubleword value via es_get_8390_hdr() above.
 */

static void es_block_input(struct net_device *dev, int count, struct sk_buff *skb,
						  int ring_offset)
{
	void __iomem *xfer_start = ei_status.mem + ring_offset - ES_START_PG*256;

	if (ring_offset + count > ES_STOP_PG*256) {
		/* Packet wraps over end of ring buffer. */
		int semi_count = ES_STOP_PG*256 - ring_offset;
		memcpy_fromio(skb->data, xfer_start, semi_count);
		count -= semi_count;
		memcpy_fromio(skb->data + semi_count, ei_status.mem, count);
	} else {
		/* Packet is in one chunk. */
		memcpy_fromio(skb->data, xfer_start, count);
	}
}

static void es_block_output(struct net_device *dev, int count,
				const unsigned char *buf, int start_page)
{
	void __iomem *shmem = ei_status.mem + ((start_page - ES_START_PG)<<8);

	count = (count + 3) & ~3;     /* Round up to doubleword */
	memcpy_toio(shmem, buf, count);
}

#ifdef MODULE
#define MAX_ES_CARDS	4	/* Max number of ES3210 cards per module */
#define NAMELEN		8	/* # of chars for storing dev->name */
static struct net_device *dev_es3210[MAX_ES_CARDS];
static int io[MAX_ES_CARDS];
static int irq[MAX_ES_CARDS];
static int mem[MAX_ES_CARDS];

module_param_array(io, int, NULL, 0);
module_param_array(irq, int, NULL, 0);
module_param_array(mem, int, NULL, 0);
MODULE_PARM_DESC(io, "I/O base address(es)");
MODULE_PARM_DESC(irq, "IRQ number(s)");
MODULE_PARM_DESC(mem, "memory base address(es)");
MODULE_DESCRIPTION("Racal-Interlan ES3210 EISA ethernet driver");
MODULE_LICENSE("GPL");

int __init init_module(void)
{
	struct net_device *dev;
	int this_dev, found = 0;

	for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
		if (io[this_dev] == 0 && this_dev != 0)
			break;
		dev = alloc_ei_netdev();
		if (!dev)
			break;
		dev->irq = irq[this_dev];
		dev->base_addr = io[this_dev];
		dev->mem_start = mem[this_dev];
		if (do_es_probe(dev) == 0) {
			dev_es3210[found++] = dev;
			continue;
		}
		free_netdev(dev);
		printk(KERN_WARNING "es3210.c: No es3210 card found (i/o = 0x%x).\n", io[this_dev]);
		break;
	}
	if (found)
		return 0;
	return -ENXIO;
}

static void cleanup_card(struct net_device *dev)
{
	free_irq(dev->irq, dev);
	release_region(dev->base_addr, ES_IO_EXTENT);
	iounmap(ei_status.mem);
}

void __exit
cleanup_module(void)
{
	int this_dev;

	for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
		struct net_device *dev = dev_es3210[this_dev];
		if (dev) {
			unregister_netdev(dev);
			cleanup_card(dev);
			free_netdev(dev);
		}
	}
}
#endif /* MODULE */
Commit	Line	Data
1da177e4 LT	1	/*
	2	es3210.c
	3
	4	Linux driver for Racal-Interlan ES3210 EISA Network Adapter
	5
	6	Copyright (C) 1996, Paul Gortmaker.
	7
	8	This software may be used and distributed according to the terms
	9	of the GNU General Public License, incorporated herein by reference.
	10
	11	Information and Code Sources:
	12
	13	1) The existing myriad of Linux 8390 drivers written by Donald Becker.
	14
	15	2) Once again Russ Nelson's asm packet driver provided additional info.
	16
	17	3) Info for getting IRQ and sh-mem gleaned from the EISA cfg files.
	18	Too bad it doesn't work -- see below.
	19
	20	The ES3210 is an EISA shared memory NS8390 implementation. Note
	21	that all memory copies to/from the board must be 32bit transfers.
	22	Which rules out using eth_io_copy_and_sum() in this driver.
	23
	24	Apparently there are two slightly different revisions of the
	25	card, since there are two distinct EISA cfg files (!rii0101.cfg
	26	and !rii0102.cfg) One has media select in the cfg file and the
	27	other doesn't. Hopefully this will work with either.
	28
	29	That is about all I can tell you about it, having never actually
	30	even seen one of these cards. :) Try http://www.interlan.com
	31	if you want more info.
	32
	33	Thanks go to Mark Salazar for testing v0.02 of this driver.
	34
	35	Bugs, to-fix, etc:
	36
	37	1) The EISA cfg ports that are supposed to have the IRQ and shared
	38	mem values just read 0xff all the time. Hrrmpf. Apparently the
	39	same happens with the packet driver as the code for reading
	40	these registers is disabled there. In the meantime, boot with:
	41	ether=<IRQ>,0,0x<shared_mem_addr>,eth0 to override the IRQ and
	42	shared memory detection. (The i/o port detection is okay.)
	43
	44	2) Module support currently untested. Probably works though.
	45
	46	*/
	47
	48	static const char version[] =
	49	"es3210.c: Driver revision v0.03, 14/09/96\n";
	50
	51	#include <linux/module.h>
	52	#include <linux/eisa.h>
	53	#include <linux/kernel.h>
	54	#include <linux/errno.h>
	55	#include <linux/string.h>
	56	#include <linux/init.h>
	57	#include <linux/netdevice.h>
	58	#include <linux/etherdevice.h>
	59
	60	#include <asm/io.h>
	61	#include <asm/system.h>
	62
	63	#include "8390.h"
	64
65	static int es_probe1(struct net_device *dev, int ioaddr);
66
1da177e4 LT	67	static void es_reset_8390(struct net_device *dev);
	68
	69	static void es_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr, int ring_page);
	70	static void es_block_input(struct net_device dev, int count, struct sk_buff skb, int ring_offset);
	71	static void es_block_output(struct net_device dev, int count, const unsigned char buf, int start_page);
	72
	73	#define ES_START_PG 0x00 /* First page of TX buffer */
	74	#define ES_STOP_PG 0x40 /* Last page +1 of RX ring */
	75
	76	#define ES_IO_EXTENT 0x37 /* The cfg file says 0xc90 -> 0xcc7 */
	77	#define ES_ID_PORT 0xc80 /* Same for all EISA cards */
	78	#define ES_SA_PROM 0xc90 /* Start of e'net addr. */
	79	#define ES_RESET_PORT 0xc84 /* From the packet driver source */
	80	#define ES_NIC_OFFSET 0xca0 /* Hello, the 8390 is here */
	81
	82	#define ES_ADDR0 0x02 /* 3 byte vendor prefix */
	83	#define ES_ADDR1 0x07
	84	#define ES_ADDR2 0x01
	85
	86	/*
	87	* Two card revisions. EISA ID's are always rev. minor, rev. major,, and
	88	* then the three vendor letters stored in 5 bits each, with an "a" = 1.
	89	* For eg: "rii" = 10010 01001 01001 = 0x4929, which is how the EISA
	90	* config utility determines automagically what config file(s) to use.
	91	*/
	92	#define ES_EISA_ID1 0x01012949 /* !rii0101.cfg */
	93	#define ES_EISA_ID2 0x02012949 /* !rii0102.cfg */
	94
	95	#define ES_CFG1 0xcc0 /* IOPORT(1) --> IOPORT(6) in cfg file */
	96	#define ES_CFG2 0xcc1
	97	#define ES_CFG3 0xcc2
	98	#define ES_CFG4 0xcc3
	99	#define ES_CFG5 0xcc4
	100	#define ES_CFG6 0xc84 /* NB: 0xc84 is also "reset" port. */
	101
	102	/*
	103	* You can OR any of the following bits together and assign it
	104	* to ES_DEBUG to get verbose driver info during operation.
	105	* Some of these don't do anything yet.
	106	*/
	107
	108	#define ES_D_PROBE 0x01
	109	#define ES_D_RX_PKT 0x02
	110	#define ES_D_TX_PKT 0x04
	111	#define ED_D_IRQ 0x08
	112
	113	#define ES_DEBUG 0
	114
	115	static unsigned char lo_irq_map[] __initdata = {3, 4, 5, 6, 7, 9, 10};
	116	static unsigned char hi_irq_map[] __initdata = {11, 12, 0, 14, 0, 0, 0, 15};
	117
	118	/*
	119	* Probe for the card. The best way is to read the EISA ID if it
	120	* is known. Then we check the prefix of the station address
	121	* PROM for a match against the Racal-Interlan assigned value.
	122	*/
	123
	124	static int __init do_es_probe(struct net_device *dev)
	125	{
	126	unsigned short ioaddr = dev->base_addr;
	127	int irq = dev->irq;
	128	int mem_start = dev->mem_start;
	129
1da177e4 LT	130	if (ioaddr > 0x1ff) /* Check a single specified location. */
	131	return es_probe1(dev, ioaddr);
	132	else if (ioaddr > 0) /* Don't probe at all. */
	133	return -ENXIO;
	134
	135	if (!EISA_bus) {
	136	#if ES_DEBUG & ES_D_PROBE
	137	printk("es3210.c: Not EISA bus. Not probing high ports.\n");
	138	#endif
	139	return -ENXIO;
	140	}
	141
	142	/* EISA spec allows for up to 16 slots, but 8 is typical. */
	143	for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
	144	if (es_probe1(dev, ioaddr) == 0)
	145	return 0;
	146	dev->irq = irq;
	147	dev->mem_start = mem_start;
	148	}
	149
	150	return -ENODEV;
	151	}
	152
1da177e4 LT	153	#ifndef MODULE
	154	struct net_device * __init es_probe(int unit)
	155	{
	156	struct net_device *dev = alloc_ei_netdev();
	157	int err;
	158
	159	if (!dev)
	160	return ERR_PTR(-ENOMEM);
	161
	162	sprintf(dev->name, "eth%d", unit);
	163	netdev_boot_setup_check(dev);
	164
	165	err = do_es_probe(dev);
	166	if (err)
	167	goto out;
1da177e4	168	return dev;
1da177e4 LT	169	out:
	170	free_netdev(dev);
	171	return ERR_PTR(err);
	172	}
	173	#endif
	174
	175	static int __init es_probe1(struct net_device *dev, int ioaddr)
	176	{
	177	int i, retval;
	178	unsigned long eisa_id;
	179
	180	if (!request_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT, "es3210"))
	181	return -ENODEV;
	182
	183	#if ES_DEBUG & ES_D_PROBE
	184	printk("es3210.c: probe at %#x, ID %#8x\n", ioaddr, inl(ioaddr + ES_ID_PORT));
	185	printk("es3210.c: config regs: %#x %#x %#x %#x %#x %#x\n",
	186	inb(ioaddr + ES_CFG1), inb(ioaddr + ES_CFG2), inb(ioaddr + ES_CFG3),
	187	inb(ioaddr + ES_CFG4), inb(ioaddr + ES_CFG5), inb(ioaddr + ES_CFG6));
	188	#endif
	189
1da177e4 LT	190	/* Check the EISA ID of the card. */
	191	eisa_id = inl(ioaddr + ES_ID_PORT);
	192	if ((eisa_id != ES_EISA_ID1) && (eisa_id != ES_EISA_ID2)) {
	193	retval = -ENODEV;
	194	goto out;
	195	}
	196
0795af57 JP	197	for (i = 0; i < ETHER_ADDR_LEN ; i++)
	198	dev->dev_addr[i] = inb(ioaddr + ES_SA_PROM + i);
	199
1da177e4	200	/* Check the Racal vendor ID as well. */
0795af57 JP	201	if (dev->dev_addr[0] != ES_ADDR0 \|\|
	202	dev->dev_addr[1] != ES_ADDR1 \|\|
	203	dev->dev_addr[2] != ES_ADDR2) {
e174961c JB	204	printk("es3210.c: card not found %pM (invalid_prefix).\n",
e174961c JB	205	dev->dev_addr);
1da177e4 LT	206	retval = -ENODEV;
	207	goto out;
	208	}
	209
e174961c JB	210	printk("es3210.c: ES3210 rev. %ld at %#x, node %pM",
e174961c JB	211	eisa_id>>24, ioaddr, dev->dev_addr);
1da177e4 LT	212
	213	/* Snarf the interrupt now. */
	214	if (dev->irq == 0) {
	215	unsigned char hi_irq = inb(ioaddr + ES_CFG2) & 0x07;
	216	unsigned char lo_irq = inb(ioaddr + ES_CFG1) & 0xfe;
	217
	218	if (hi_irq != 0) {
	219	dev->irq = hi_irq_map[hi_irq - 1];
	220	} else {
	221	int i = 0;
	222	while (lo_irq > (1<<i)) i++;
	223	dev->irq = lo_irq_map[i];
	224	}
	225	printk(" using IRQ %d", dev->irq);
	226	#if ES_DEBUG & ES_D_PROBE
	227	printk("es3210.c: hi_irq %#x, lo_irq %#x, dev->irq = %d\n",
	228	hi_irq, lo_irq, dev->irq);
	229	#endif
	230	} else {
	231	if (dev->irq == 2)
	232	dev->irq = 9; /* Doh! */
	233	printk(" assigning IRQ %d", dev->irq);
	234	}
	235
	236	if (request_irq(dev->irq, ei_interrupt, 0, "es3210", dev)) {
	237	printk (" unable to get IRQ %d.\n", dev->irq);
	238	retval = -EAGAIN;
	239	goto out;
	240	}
	241
	242	if (dev->mem_start == 0) {
	243	unsigned char mem_enabled = inb(ioaddr + ES_CFG2) & 0xc0;
	244	unsigned char mem_bits = inb(ioaddr + ES_CFG3) & 0x07;
	245
	246	if (mem_enabled != 0x80) {
	247	printk(" shared mem disabled - giving up\n");
	248	retval = -ENXIO;
	249	goto out1;
	250	}
	251	dev->mem_start = 0xC0000 + mem_bits*0x4000;
	252	printk(" using ");
	253	} else {
	254	printk(" assigning ");
	255	}
	256
	257	ei_status.mem = ioremap(dev->mem_start, (ES_STOP_PG - ES_START_PG)*256);
	258	if (!ei_status.mem) {
	259	printk("ioremap failed - giving up\n");
	260	retval = -ENXIO;
	261	goto out1;
	262	}
	263
	264	dev->mem_end = dev->mem_start + (ES_STOP_PG - ES_START_PG)*256;
	265
	266	printk("mem %#lx-%#lx\n", dev->mem_start, dev->mem_end-1);
	267
	268	#if ES_DEBUG & ES_D_PROBE
	269	if (inb(ioaddr + ES_CFG5))
	270	printk("es3210: Warning - DMA channel enabled, but not used here.\n");
	271	#endif
	272	/* Note, point at the 8390, and not the card... */
	273	dev->base_addr = ioaddr + ES_NIC_OFFSET;
	274
	275	ei_status.name = "ES3210";
276	ei_status.tx_start_page = ES_START_PG;
277	ei_status.rx_start_page = ES_START_PG + TX_PAGES;
278	ei_status.stop_page = ES_STOP_PG;
279	ei_status.word16 = 1;
280
281	if (ei_debug > 0)
282	printk(version);
283
284	ei_status.reset_8390 = &es_reset_8390;
285	ei_status.block_input = &es_block_input;
286	ei_status.block_output = &es_block_output;
287	ei_status.get_8390_hdr = &es_get_8390_hdr;
288
9a9aa14a	289	dev->netdev_ops = &ei_netdev_ops;
1da177e4	290	NS8390_init(dev, 0);
b1fc5505 HX	291
	292	retval = register_netdev(dev);
	293	if (retval)
	294	goto out1;
1da177e4 LT	295	return 0;
	296	out1:
	297	free_irq(dev->irq, dev);
	298	out:
	299	release_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT);
	300	return retval;
	301	}
	302
	303	/*
	304	* Reset as per the packet driver method. Judging by the EISA cfg
	305	* file, this just toggles the "Board Enable" bits (bit 2 and 0).
	306	*/
	307
	308	static void es_reset_8390(struct net_device *dev)
	309	{
	310	unsigned short ioaddr = dev->base_addr;
	311	unsigned long end;
	312
	313	outb(0x04, ioaddr + ES_RESET_PORT);
	314	if (ei_debug > 1) printk("%s: resetting the ES3210...", dev->name);
	315
	316	end = jiffies + 2*HZ/100;
	317	while ((signed)(end - jiffies) > 0) continue;
	318
	319	ei_status.txing = 0;
	320	outb(0x01, ioaddr + ES_RESET_PORT);
	321	if (ei_debug > 1) printk("reset done\n");
1da177e4 LT	322	}
	323
	324	/*
	325	* Note: In the following three functions is the implicit assumption
	326	* that the associated memcpy will only use "rep; movsl" as long as
	327	* we keep the counts as some multiple of doublewords. This is a
	328	* requirement of the hardware, and also prevents us from using
	329	* eth_io_copy_and_sum() since we can't guarantee it will limit
	330	* itself to doubleword access.
	331	*/
	332
	333	/*
	334	* Grab the 8390 specific header. Similar to the block_input routine, but
	335	* we don't need to be concerned with ring wrap as the header will be at
	336	* the start of a page, so we optimize accordingly. (A single doubleword.)
	337	*/
	338
	339	static void
	340	es_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr, int ring_page)
	341	{
	342	void __iomem *hdr_start = ei_status.mem + ((ring_page - ES_START_PG)<<8);
	343	memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
	344	hdr->count = (hdr->count + 3) & ~3; /* Round up allocation. */
	345	}
	346
	347	/*
	348	* Block input and output are easy on shared memory ethercards, the only
	349	* complication is when the ring buffer wraps. The count will already
	350	* be rounded up to a doubleword value via es_get_8390_hdr() above.
	351	*/
	352
	353	static void es_block_input(struct net_device dev, int count, struct sk_buff skb,
	354	int ring_offset)
	355	{
	356	void __iomem xfer_start = ei_status.mem + ring_offset - ES_START_PG256;
	357
	358	if (ring_offset + count > ES_STOP_PG*256) {
	359	/* Packet wraps over end of ring buffer. */
	360	int semi_count = ES_STOP_PG*256 - ring_offset;
	361	memcpy_fromio(skb->data, xfer_start, semi_count);
	362	count -= semi_count;
	363	memcpy_fromio(skb->data + semi_count, ei_status.mem, count);
	364	} else {
	365	/* Packet is in one chunk. */
4ec03116	366	memcpy_fromio(skb->data, xfer_start, count);
1da177e4 LT	367	}
	368	}
	369
	370	static void es_block_output(struct net_device *dev, int count,
	371	const unsigned char *buf, int start_page)
	372	{
	373	void __iomem *shmem = ei_status.mem + ((start_page - ES_START_PG)<<8);
	374
	375	count = (count + 3) & ~3; /* Round up to doubleword */
	376	memcpy_toio(shmem, buf, count);
	377	}
	378
1da177e4 LT	379	#ifdef MODULE
	380	#define MAX_ES_CARDS 4 /* Max number of ES3210 cards per module */
	381	#define NAMELEN 8 /* # of chars for storing dev->name */
	382	static struct net_device *dev_es3210[MAX_ES_CARDS];
	383	static int io[MAX_ES_CARDS];
	384	static int irq[MAX_ES_CARDS];
	385	static int mem[MAX_ES_CARDS];
	386
	387	module_param_array(io, int, NULL, 0);
	388	module_param_array(irq, int, NULL, 0);
	389	module_param_array(mem, int, NULL, 0);
	390	MODULE_PARM_DESC(io, "I/O base address(es)");
	391	MODULE_PARM_DESC(irq, "IRQ number(s)");
	392	MODULE_PARM_DESC(mem, "memory base address(es)");
	393	MODULE_DESCRIPTION("Racal-Interlan ES3210 EISA ethernet driver");
	394	MODULE_LICENSE("GPL");
	395
5757f5c6	396	int __init init_module(void)
1da177e4 LT	397	{
	398	struct net_device *dev;
	399	int this_dev, found = 0;
	400
	401	for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
	402	if (io[this_dev] == 0 && this_dev != 0)
	403	break;
	404	dev = alloc_ei_netdev();
	405	if (!dev)
	406	break;
	407	dev->irq = irq[this_dev];
	408	dev->base_addr = io[this_dev];
	409	dev->mem_start = mem[this_dev];
	410	if (do_es_probe(dev) == 0) {
b1fc5505 HX	411	dev_es3210[found++] = dev;
b1fc5505 HX	412	continue;
1da177e4 LT	413	}
	414	free_netdev(dev);
	415	printk(KERN_WARNING "es3210.c: No es3210 card found (i/o = 0x%x).\n", io[this_dev]);
	416	break;
	417	}
	418	if (found)
	419	return 0;
	420	return -ENXIO;
	421	}
	422
64916f1e DV	423	static void cleanup_card(struct net_device *dev)
	424	{
	425	free_irq(dev->irq, dev);
	426	release_region(dev->base_addr, ES_IO_EXTENT);
	427	iounmap(ei_status.mem);
	428	}
	429
afc8eb46	430	void __exit
1da177e4 LT	431	cleanup_module(void)
	432	{
	433	int this_dev;
	434
	435	for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
	436	struct net_device *dev = dev_es3210[this_dev];
	437	if (dev) {
	438	unregister_netdev(dev);
	439	cleanup_card(dev);
	440	free_netdev(dev);
	441	}
	442	}
	443	}
	444	#endif /* MODULE */
	445