[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 int es_open(struct net_device *dev);
static int es_close(struct net_device *dev);

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->open = &es_open;
	dev->stop = &es_close;
#ifdef CONFIG_NET_POLL_CONTROLLER
	dev->poll_controller = ei_poll;
#endif
	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");

	return;
}

/*
 *	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);
}

static int es_open(struct net_device *dev)
{
	ei_open(dev);
	return 0;
}

static int es_close(struct net_device *dev)
{

	if (ei_debug > 1)
		printk("%s: Shutting down ethercard.\n", dev->name);

	ei_close(dev);
	return 0;
}

#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
67	static int es_open(struct net_device *dev);
68	static int es_close(struct net_device *dev);
69
70	static void es_reset_8390(struct net_device *dev);
71
72	static void es_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr, int ring_page);
73	static void es_block_input(struct net_device dev, int count, struct sk_buff skb, int ring_offset);
74	static void es_block_output(struct net_device dev, int count, const unsigned char buf, int start_page);
75
76	#define ES_START_PG 0x00 /* First page of TX buffer */
77	#define ES_STOP_PG 0x40 /* Last page +1 of RX ring */
78
79	#define ES_IO_EXTENT 0x37 /* The cfg file says 0xc90 -> 0xcc7 */
80	#define ES_ID_PORT 0xc80 /* Same for all EISA cards */
81	#define ES_SA_PROM 0xc90 /* Start of e'net addr. */
82	#define ES_RESET_PORT 0xc84 /* From the packet driver source */
83	#define ES_NIC_OFFSET 0xca0 /* Hello, the 8390 is here */
84
85	#define ES_ADDR0 0x02 /* 3 byte vendor prefix */
86	#define ES_ADDR1 0x07
87	#define ES_ADDR2 0x01
88
89	/*
90	* Two card revisions. EISA ID's are always rev. minor, rev. major,, and
91	* then the three vendor letters stored in 5 bits each, with an "a" = 1.
92	* For eg: "rii" = 10010 01001 01001 = 0x4929, which is how the EISA
93	* config utility determines automagically what config file(s) to use.
94	*/
95	#define ES_EISA_ID1 0x01012949 /* !rii0101.cfg */
96	#define ES_EISA_ID2 0x02012949 /* !rii0102.cfg */
97
98	#define ES_CFG1 0xcc0 /* IOPORT(1) --> IOPORT(6) in cfg file */
99	#define ES_CFG2 0xcc1
100	#define ES_CFG3 0xcc2
101	#define ES_CFG4 0xcc3
102	#define ES_CFG5 0xcc4
103	#define ES_CFG6 0xc84 /* NB: 0xc84 is also "reset" port. */
104
105	/*
106	* You can OR any of the following bits together and assign it
107	* to ES_DEBUG to get verbose driver info during operation.
108	* Some of these don't do anything yet.
109	*/
110
111	#define ES_D_PROBE 0x01
112	#define ES_D_RX_PKT 0x02
113	#define ES_D_TX_PKT 0x04
114	#define ED_D_IRQ 0x08
115
116	#define ES_DEBUG 0
117
118	static unsigned char lo_irq_map[] __initdata = {3, 4, 5, 6, 7, 9, 10};
119	static unsigned char hi_irq_map[] __initdata = {11, 12, 0, 14, 0, 0, 0, 15};
120
121	/*
122	* Probe for the card. The best way is to read the EISA ID if it
123	* is known. Then we check the prefix of the station address
124	* PROM for a match against the Racal-Interlan assigned value.
125	*/
126
127	static int __init do_es_probe(struct net_device *dev)
128	{
129	unsigned short ioaddr = dev->base_addr;
130	int irq = dev->irq;
131	int mem_start = dev->mem_start;
132
1da177e4 LT	133	if (ioaddr > 0x1ff) /* Check a single specified location. */
	134	return es_probe1(dev, ioaddr);
	135	else if (ioaddr > 0) /* Don't probe at all. */
	136	return -ENXIO;
	137
	138	if (!EISA_bus) {
	139	#if ES_DEBUG & ES_D_PROBE
	140	printk("es3210.c: Not EISA bus. Not probing high ports.\n");
	141	#endif
	142	return -ENXIO;
	143	}
	144
	145	/* EISA spec allows for up to 16 slots, but 8 is typical. */
	146	for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
	147	if (es_probe1(dev, ioaddr) == 0)
	148	return 0;
	149	dev->irq = irq;
	150	dev->mem_start = mem_start;
	151	}
	152
	153	return -ENODEV;
	154	}
	155
1da177e4 LT	156	#ifndef MODULE
	157	struct net_device * __init es_probe(int unit)
	158	{
	159	struct net_device *dev = alloc_ei_netdev();
	160	int err;
	161
	162	if (!dev)
	163	return ERR_PTR(-ENOMEM);
	164
	165	sprintf(dev->name, "eth%d", unit);
	166	netdev_boot_setup_check(dev);
	167
	168	err = do_es_probe(dev);
	169	if (err)
	170	goto out;
1da177e4	171	return dev;
1da177e4 LT	172	out:
	173	free_netdev(dev);
	174	return ERR_PTR(err);
	175	}
	176	#endif
	177
	178	static int __init es_probe1(struct net_device *dev, int ioaddr)
	179	{
	180	int i, retval;
	181	unsigned long eisa_id;
	182
	183	if (!request_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT, "es3210"))
	184	return -ENODEV;
	185
	186	#if ES_DEBUG & ES_D_PROBE
	187	printk("es3210.c: probe at %#x, ID %#8x\n", ioaddr, inl(ioaddr + ES_ID_PORT));
	188	printk("es3210.c: config regs: %#x %#x %#x %#x %#x %#x\n",
	189	inb(ioaddr + ES_CFG1), inb(ioaddr + ES_CFG2), inb(ioaddr + ES_CFG3),
	190	inb(ioaddr + ES_CFG4), inb(ioaddr + ES_CFG5), inb(ioaddr + ES_CFG6));
	191	#endif
	192
1da177e4 LT	193	/* Check the EISA ID of the card. */
	194	eisa_id = inl(ioaddr + ES_ID_PORT);
	195	if ((eisa_id != ES_EISA_ID1) && (eisa_id != ES_EISA_ID2)) {
	196	retval = -ENODEV;
	197	goto out;
	198	}
	199
0795af57 JP	200	for (i = 0; i < ETHER_ADDR_LEN ; i++)
	201	dev->dev_addr[i] = inb(ioaddr + ES_SA_PROM + i);
	202
1da177e4	203	/* Check the Racal vendor ID as well. */
0795af57 JP	204	if (dev->dev_addr[0] != ES_ADDR0 \|\|
	205	dev->dev_addr[1] != ES_ADDR1 \|\|
	206	dev->dev_addr[2] != ES_ADDR2) {
e174961c JB	207	printk("es3210.c: card not found %pM (invalid_prefix).\n",
e174961c JB	208	dev->dev_addr);
1da177e4 LT	209	retval = -ENODEV;
	210	goto out;
	211	}
	212
e174961c JB	213	printk("es3210.c: ES3210 rev. %ld at %#x, node %pM",
e174961c JB	214	eisa_id>>24, ioaddr, dev->dev_addr);
1da177e4 LT	215
	216	/* Snarf the interrupt now. */
	217	if (dev->irq == 0) {
	218	unsigned char hi_irq = inb(ioaddr + ES_CFG2) & 0x07;
	219	unsigned char lo_irq = inb(ioaddr + ES_CFG1) & 0xfe;
	220
	221	if (hi_irq != 0) {
	222	dev->irq = hi_irq_map[hi_irq - 1];
	223	} else {
	224	int i = 0;
	225	while (lo_irq > (1<<i)) i++;
	226	dev->irq = lo_irq_map[i];
	227	}
	228	printk(" using IRQ %d", dev->irq);
	229	#if ES_DEBUG & ES_D_PROBE
	230	printk("es3210.c: hi_irq %#x, lo_irq %#x, dev->irq = %d\n",
	231	hi_irq, lo_irq, dev->irq);
	232	#endif
	233	} else {
	234	if (dev->irq == 2)
	235	dev->irq = 9; /* Doh! */
	236	printk(" assigning IRQ %d", dev->irq);
	237	}
	238
	239	if (request_irq(dev->irq, ei_interrupt, 0, "es3210", dev)) {
	240	printk (" unable to get IRQ %d.\n", dev->irq);
	241	retval = -EAGAIN;
	242	goto out;
	243	}
	244
	245	if (dev->mem_start == 0) {
	246	unsigned char mem_enabled = inb(ioaddr + ES_CFG2) & 0xc0;
	247	unsigned char mem_bits = inb(ioaddr + ES_CFG3) & 0x07;
	248
	249	if (mem_enabled != 0x80) {
	250	printk(" shared mem disabled - giving up\n");
	251	retval = -ENXIO;
	252	goto out1;
	253	}
	254	dev->mem_start = 0xC0000 + mem_bits*0x4000;
	255	printk(" using ");
	256	} else {
	257	printk(" assigning ");
	258	}
	259
	260	ei_status.mem = ioremap(dev->mem_start, (ES_STOP_PG - ES_START_PG)*256);
	261	if (!ei_status.mem) {
	262	printk("ioremap failed - giving up\n");
	263	retval = -ENXIO;
	264	goto out1;
	265	}
	266
	267	dev->mem_end = dev->mem_start + (ES_STOP_PG - ES_START_PG)*256;
	268
	269	printk("mem %#lx-%#lx\n", dev->mem_start, dev->mem_end-1);
	270
	271	#if ES_DEBUG & ES_D_PROBE
	272	if (inb(ioaddr + ES_CFG5))
	273	printk("es3210: Warning - DMA channel enabled, but not used here.\n");
	274	#endif
	275	/* Note, point at the 8390, and not the card... */
	276	dev->base_addr = ioaddr + ES_NIC_OFFSET;
	277
	278	ei_status.name = "ES3210";
279	ei_status.tx_start_page = ES_START_PG;
280	ei_status.rx_start_page = ES_START_PG + TX_PAGES;
281	ei_status.stop_page = ES_STOP_PG;
282	ei_status.word16 = 1;
283
284	if (ei_debug > 0)
285	printk(version);
286
287	ei_status.reset_8390 = &es_reset_8390;
288	ei_status.block_input = &es_block_input;
289	ei_status.block_output = &es_block_output;
290	ei_status.get_8390_hdr = &es_get_8390_hdr;
291
292	dev->open = &es_open;
293	dev->stop = &es_close;
294	#ifdef CONFIG_NET_POLL_CONTROLLER
295	dev->poll_controller = ei_poll;
296	#endif
297	NS8390_init(dev, 0);
b1fc5505 HX	298
	299	retval = register_netdev(dev);
	300	if (retval)
	301	goto out1;
1da177e4 LT	302	return 0;
	303	out1:
	304	free_irq(dev->irq, dev);
	305	out:
	306	release_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT);
	307	return retval;
	308	}
	309
	310	/*
	311	* Reset as per the packet driver method. Judging by the EISA cfg
	312	* file, this just toggles the "Board Enable" bits (bit 2 and 0).
	313	*/
	314
	315	static void es_reset_8390(struct net_device *dev)
	316	{
	317	unsigned short ioaddr = dev->base_addr;
	318	unsigned long end;
	319
	320	outb(0x04, ioaddr + ES_RESET_PORT);
	321	if (ei_debug > 1) printk("%s: resetting the ES3210...", dev->name);
	322
	323	end = jiffies + 2*HZ/100;
	324	while ((signed)(end - jiffies) > 0) continue;
	325
	326	ei_status.txing = 0;
	327	outb(0x01, ioaddr + ES_RESET_PORT);
	328	if (ei_debug > 1) printk("reset done\n");
	329
	330	return;
	331	}
	332
	333	/*
	334	* Note: In the following three functions is the implicit assumption
	335	* that the associated memcpy will only use "rep; movsl" as long as
	336	* we keep the counts as some multiple of doublewords. This is a
	337	* requirement of the hardware, and also prevents us from using
	338	* eth_io_copy_and_sum() since we can't guarantee it will limit
	339	* itself to doubleword access.
	340	*/
	341
	342	/*
	343	* Grab the 8390 specific header. Similar to the block_input routine, but
	344	* we don't need to be concerned with ring wrap as the header will be at
	345	* the start of a page, so we optimize accordingly. (A single doubleword.)
	346	*/
	347
	348	static void
	349	es_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr, int ring_page)
	350	{
	351	void __iomem *hdr_start = ei_status.mem + ((ring_page - ES_START_PG)<<8);
	352	memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
	353	hdr->count = (hdr->count + 3) & ~3; /* Round up allocation. */
	354	}
	355
	356	/*
	357	* Block input and output are easy on shared memory ethercards, the only
	358	* complication is when the ring buffer wraps. The count will already
	359	* be rounded up to a doubleword value via es_get_8390_hdr() above.
	360	*/
	361
	362	static void es_block_input(struct net_device dev, int count, struct sk_buff skb,
	363	int ring_offset)
	364	{
	365	void __iomem xfer_start = ei_status.mem + ring_offset - ES_START_PG256;
366
367	if (ring_offset + count > ES_STOP_PG*256) {
368	/* Packet wraps over end of ring buffer. */
369	int semi_count = ES_STOP_PG*256 - ring_offset;
370	memcpy_fromio(skb->data, xfer_start, semi_count);
371	count -= semi_count;
372	memcpy_fromio(skb->data + semi_count, ei_status.mem, count);
373	} else {
374	/* Packet is in one chunk. */
4ec03116	375	memcpy_fromio(skb->data, xfer_start, count);
1da177e4 LT	376	}
	377	}
	378
	379	static void es_block_output(struct net_device *dev, int count,
	380	const unsigned char *buf, int start_page)
	381	{
	382	void __iomem *shmem = ei_status.mem + ((start_page - ES_START_PG)<<8);
	383
	384	count = (count + 3) & ~3; /* Round up to doubleword */
	385	memcpy_toio(shmem, buf, count);
	386	}
	387
	388	static int es_open(struct net_device *dev)
	389	{
	390	ei_open(dev);
	391	return 0;
	392	}
	393
	394	static int es_close(struct net_device *dev)
	395	{
	396
	397	if (ei_debug > 1)
	398	printk("%s: Shutting down ethercard.\n", dev->name);
	399
	400	ei_close(dev);
	401	return 0;
	402	}
	403
	404	#ifdef MODULE
	405	#define MAX_ES_CARDS 4 /* Max number of ES3210 cards per module */
	406	#define NAMELEN 8 /* # of chars for storing dev->name */
	407	static struct net_device *dev_es3210[MAX_ES_CARDS];
	408	static int io[MAX_ES_CARDS];
	409	static int irq[MAX_ES_CARDS];
	410	static int mem[MAX_ES_CARDS];
	411
	412	module_param_array(io, int, NULL, 0);
	413	module_param_array(irq, int, NULL, 0);
	414	module_param_array(mem, int, NULL, 0);
	415	MODULE_PARM_DESC(io, "I/O base address(es)");
	416	MODULE_PARM_DESC(irq, "IRQ number(s)");
	417	MODULE_PARM_DESC(mem, "memory base address(es)");
	418	MODULE_DESCRIPTION("Racal-Interlan ES3210 EISA ethernet driver");
	419	MODULE_LICENSE("GPL");
	420
5757f5c6	421	int __init init_module(void)
1da177e4 LT	422	{
	423	struct net_device *dev;
	424	int this_dev, found = 0;
	425
	426	for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
	427	if (io[this_dev] == 0 && this_dev != 0)
	428	break;
	429	dev = alloc_ei_netdev();
	430	if (!dev)
	431	break;
	432	dev->irq = irq[this_dev];
	433	dev->base_addr = io[this_dev];
	434	dev->mem_start = mem[this_dev];
	435	if (do_es_probe(dev) == 0) {
b1fc5505 HX	436	dev_es3210[found++] = dev;
b1fc5505 HX	437	continue;
1da177e4 LT	438	}
	439	free_netdev(dev);
	440	printk(KERN_WARNING "es3210.c: No es3210 card found (i/o = 0x%x).\n", io[this_dev]);
	441	break;
	442	}
	443	if (found)
	444	return 0;
	445	return -ENXIO;
	446	}
	447
64916f1e DV	448	static void cleanup_card(struct net_device *dev)
	449	{
	450	free_irq(dev->irq, dev);
	451	release_region(dev->base_addr, ES_IO_EXTENT);
	452	iounmap(ei_status.mem);
	453	}
	454
afc8eb46	455	void __exit
1da177e4 LT	456	cleanup_module(void)
	457	{
	458	int this_dev;
	459
	460	for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
	461	struct net_device *dev = dev_es3210[this_dev];
	462	if (dev) {
	463	unregister_netdev(dev);
	464	cleanup_card(dev);
	465	free_netdev(dev);
	466	}
	467	}
	468	}
	469	#endif /* MODULE */
	470