[deliverable/linux.git] / drivers / net / ac3200.c

/* ac3200.c: A driver for the Ansel Communications EISA ethernet adaptor. */
/*
	Written 1993, 1994 by Donald Becker.
	Copyright 1993 United States Government as represented by the Director,
	National Security Agency.  This software may only be used and distributed
	according to the terms of the GNU General Public License as modified by SRC,
	incorporated herein by reference.

	The author may be reached as becker@scyld.com, or C/O
	Scyld Computing Corporation
	410 Severn Ave., Suite 210
	Annapolis MD 21403

	This is driver for the Ansel Communications Model 3200 EISA Ethernet LAN
	Adapter.  The programming information is from the users manual, as related
	by glee@ardnassak.math.clemson.edu.

	Changelog:

	Paul Gortmaker 05/98	: add support for shared mem above 1MB.

  */

static const char version[] =
	"ac3200.c:v1.01 7/1/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";

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

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

#include "8390.h"

#define DRV_NAME	"ac3200"

/* Offsets from the base address. */
#define AC_NIC_BASE	0x00
#define AC_SA_PROM	0x16			/* The station address PROM. */
#define AC_ADDR0	0x00			/* Prefix station address values. */
#define AC_ADDR1	0x40
#define AC_ADDR2	0x90
#define AC_ID_PORT	0xC80
#define AC_EISA_ID	0x0110d305
#define AC_RESET_PORT	0xC84
#define AC_RESET	0x00
#define AC_ENABLE	0x01
#define AC_CONFIG	0xC90	/* The configuration port. */

#define AC_IO_EXTENT 0x20
                                /* Actually accessed is:
								 * AC_NIC_BASE (0-15)
								 * AC_SA_PROM (0-5)
								 * AC_ID_PORT (0-3)
								 * AC_RESET_PORT
								 * AC_CONFIG
								 */

/* Decoding of the configuration register. */
static unsigned char config2irqmap[8] __initdata = {15, 12, 11, 10, 9, 7, 5, 3};
static int addrmap[8] =
{0xFF0000, 0xFE0000, 0xFD0000, 0xFFF0000, 0xFFE0000, 0xFFC0000,  0xD0000, 0 };
static const char *port_name[4] = { "10baseT", "invalid", "AUI", "10base2"};

#define config2irq(configval)	config2irqmap[((configval) >> 3) & 7]
#define config2mem(configval)	addrmap[(configval) & 7]
#define config2name(configval)	port_name[((configval) >> 6) & 3]

/* First and last 8390 pages. */
#define AC_START_PG		0x00	/* First page of 8390 TX buffer */
#define AC_STOP_PG		0x80	/* Last page +1 of the 8390 RX ring */

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

static int ac_open(struct net_device *dev);
static void ac_reset_8390(struct net_device *dev);
static void ac_block_input(struct net_device *dev, int count,
					struct sk_buff *skb, int ring_offset);
static void ac_block_output(struct net_device *dev, const int count,
							const unsigned char *buf, const int start_page);
static void ac_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
					int ring_page);

static int ac_close_card(struct net_device *dev);


/*	Probe for the AC3200.

	The AC3200 can be identified by either the EISA configuration registers,
	or the unique value in the station address PROM.
	*/

static int __init do_ac3200_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 ac_probe1(ioaddr, dev);
	else if (ioaddr > 0)		/* Don't probe at all. */
		return -ENXIO;

	if ( ! EISA_bus)
		return -ENXIO;

	for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
		if (ac_probe1(ioaddr, dev) == 0)
			return 0;
		dev->irq = irq;
		dev->mem_start = mem_start;
	}

	return -ENODEV;
}

#ifndef MODULE
struct net_device * __init ac3200_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_ac3200_probe(dev);
	if (err)
		goto out;
	return dev;
out:
	free_netdev(dev);
	return ERR_PTR(err);
}
#endif

static int __init ac_probe1(int ioaddr, struct net_device *dev)
{
	int i, retval;

	if (!request_region(ioaddr, AC_IO_EXTENT, DRV_NAME))
		return -EBUSY;

	if (inb_p(ioaddr + AC_ID_PORT) == 0xff) {
		retval = -ENODEV;
		goto out;
	}

	if (inl(ioaddr + AC_ID_PORT) != AC_EISA_ID) {
		retval = -ENODEV;
		goto out;
	}

#ifndef final_version
	printk(KERN_DEBUG "AC3200 ethercard configuration register is %#02x,"
		   " EISA ID %02x %02x %02x %02x.\n", inb(ioaddr + AC_CONFIG),
		   inb(ioaddr + AC_ID_PORT + 0), inb(ioaddr + AC_ID_PORT + 1),
		   inb(ioaddr + AC_ID_PORT + 2), inb(ioaddr + AC_ID_PORT + 3));
#endif

	printk("AC3200 in EISA slot %d, node", ioaddr/0x1000);
	for(i = 0; i < 6; i++)
		printk(" %02x", dev->dev_addr[i] = inb(ioaddr + AC_SA_PROM + i));

#if 0
	/* Check the vendor ID/prefix. Redundant after checking the EISA ID */
	if (inb(ioaddr + AC_SA_PROM + 0) != AC_ADDR0
		|| inb(ioaddr + AC_SA_PROM + 1) != AC_ADDR1
		|| inb(ioaddr + AC_SA_PROM + 2) != AC_ADDR2 ) {
		printk(", not found (invalid prefix).\n");
		retval = -ENODEV;
		goto out;
	}
#endif

	/* Assign and allocate the interrupt now. */
	if (dev->irq == 0) {
		dev->irq = config2irq(inb(ioaddr + AC_CONFIG));
		printk(", using");
	} else {
		dev->irq = irq_canonicalize(dev->irq);
		printk(", assigning");
	}

	retval = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
	if (retval) {
		printk (" nothing! Unable to get IRQ %d.\n", dev->irq);
		goto out1;
	}

	printk(" IRQ %d, %s port\n", dev->irq, port_name[dev->if_port]);

	dev->base_addr = ioaddr;

#ifdef notyet
	if (dev->mem_start)	{		/* Override the value from the board. */
		for (i = 0; i < 7; i++)
			if (addrmap[i] == dev->mem_start)
				break;
		if (i >= 7)
			i = 0;
		outb((inb(ioaddr + AC_CONFIG) & ~7) | i, ioaddr + AC_CONFIG);
	}
#endif

	dev->if_port = inb(ioaddr + AC_CONFIG) >> 6;
	dev->mem_start = config2mem(inb(ioaddr + AC_CONFIG));

	printk("%s: AC3200 at %#3x with %dkB memory at physical address %#lx.\n",
			dev->name, ioaddr, AC_STOP_PG/4, dev->mem_start);

	/*
	 *  BEWARE!! Some dain-bramaged EISA SCUs will allow you to put
	 *  the card mem within the region covered by `normal' RAM  !!!
	 *
	 *  ioremap() will fail in that case.
	 */
	ei_status.mem = ioremap(dev->mem_start, AC_STOP_PG*0x100);
	if (!ei_status.mem) {
		printk(KERN_ERR "ac3200.c: Unable to remap card memory above 1MB !!\n");
		printk(KERN_ERR "ac3200.c: Try using EISA SCU to set memory below 1MB.\n");
		printk(KERN_ERR "ac3200.c: Driver NOT installed.\n");
		retval = -EINVAL;
		goto out1;
	}
	printk("ac3200.c: remapped %dkB card memory to virtual address %p\n",
			AC_STOP_PG/4, ei_status.mem);

	dev->mem_start = (unsigned long)ei_status.mem;
	dev->mem_end = dev->mem_start + (AC_STOP_PG - AC_START_PG)*256;

	ei_status.name = "AC3200";
	ei_status.tx_start_page = AC_START_PG;
	ei_status.rx_start_page = AC_START_PG + TX_PAGES;
	ei_status.stop_page = AC_STOP_PG;
	ei_status.word16 = 1;

	if (ei_debug > 0)
		printk(version);

	ei_status.reset_8390 = &ac_reset_8390;
	ei_status.block_input = &ac_block_input;
	ei_status.block_output = &ac_block_output;
	ei_status.get_8390_hdr = &ac_get_8390_hdr;

	dev->open = &ac_open;
	dev->stop = &ac_close_card;
#ifdef CONFIG_NET_POLL_CONTROLLER
	dev->poll_controller = ei_poll;
#endif
	NS8390_init(dev, 0);

	retval = register_netdev(dev);
	if (retval)
		goto out2;
	return 0;
out2:
	if (ei_status.reg0)
		iounmap(ei_status.mem);
out1:
	free_irq(dev->irq, dev);
out:
	release_region(ioaddr, AC_IO_EXTENT);
	return retval;
}

static int ac_open(struct net_device *dev)
{
#ifdef notyet
	/* Someday we may enable the IRQ and shared memory here. */
	int ioaddr = dev->base_addr;
#endif

	ei_open(dev);
	return 0;
}

static void ac_reset_8390(struct net_device *dev)
{
	ushort ioaddr = dev->base_addr;

	outb(AC_RESET, ioaddr + AC_RESET_PORT);
	if (ei_debug > 1) printk("resetting AC3200, t=%ld...", jiffies);

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

	return;
}

/* 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. */

static void
ac_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
{
	void __iomem *hdr_start = ei_status.mem + ((ring_page - AC_START_PG)<<8);
	memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
}

/*  Block input and output are easy on shared memory ethercards, the only
	complication is when the ring buffer wraps. */

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

	if (ring_offset + count > AC_STOP_PG*256) {
		/* We must wrap the input move. */
		int semi_count = AC_STOP_PG*256 - ring_offset;
		memcpy_fromio(skb->data, start, semi_count);
		count -= semi_count;
		memcpy_fromio(skb->data + semi_count,
				ei_status.mem + TX_PAGES*256, count);
	} else {
		memcpy_fromio(skb->data, start, count);
	}
}

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

	memcpy_toio(shmem, buf, count);
}

static int ac_close_card(struct net_device *dev)
{
	if (ei_debug > 1)
		printk("%s: Shutting down ethercard.\n", dev->name);

#ifdef notyet
	/* We should someday disable shared memory and interrupts. */
	outb(0x00, ioaddr + 6);	/* Disable interrupts. */
	free_irq(dev->irq, dev);
#endif

	ei_close(dev);
	return 0;
}

#ifdef MODULE
#define MAX_AC32_CARDS	4	/* Max number of AC32 cards per module */
static struct net_device *dev_ac32[MAX_AC32_CARDS];
static int io[MAX_AC32_CARDS];
static int irq[MAX_AC32_CARDS];
static int mem[MAX_AC32_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("Ansel AC3200 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_AC32_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];		/* Currently ignored by driver */
		if (do_ac3200_probe(dev) == 0) {
			dev_ac32[found++] = dev;
			continue;
		}
		free_netdev(dev);
		printk(KERN_WARNING "ac3200.c: No ac3200 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)
{
	/* Someday free_irq may be in ac_close_card() */
	free_irq(dev->irq, dev);
	release_region(dev->base_addr, AC_IO_EXTENT);
	iounmap(ei_status.mem);
}

void __exit
cleanup_module(void)
{
	int this_dev;

	for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) {
		struct net_device *dev = dev_ac32[this_dev];
		if (dev) {
			unregister_netdev(dev);
			cleanup_card(dev);
			free_netdev(dev);
		}
	}
}
#endif /* MODULE */
Commit	Line	Data
1da177e4 LT	1	/* ac3200.c: A driver for the Ansel Communications EISA ethernet adaptor. */
	2	/*
	3	Written 1993, 1994 by Donald Becker.
	4	Copyright 1993 United States Government as represented by the Director,
	5	National Security Agency. This software may only be used and distributed
	6	according to the terms of the GNU General Public License as modified by SRC,
	7	incorporated herein by reference.
	8
	9	The author may be reached as becker@scyld.com, or C/O
	10	Scyld Computing Corporation
	11	410 Severn Ave., Suite 210
	12	Annapolis MD 21403
	13
	14	This is driver for the Ansel Communications Model 3200 EISA Ethernet LAN
	15	Adapter. The programming information is from the users manual, as related
	16	by glee@ardnassak.math.clemson.edu.
	17
	18	Changelog:
	19
	20	Paul Gortmaker 05/98 : add support for shared mem above 1MB.
	21
	22	*/
	23
	24	static const char version[] =
	25	"ac3200.c:v1.01 7/1/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
	26
	27	#include <linux/module.h>
	28	#include <linux/eisa.h>
	29	#include <linux/kernel.h>
	30	#include <linux/errno.h>
	31	#include <linux/string.h>
	32	#include <linux/netdevice.h>
	33	#include <linux/etherdevice.h>
	34	#include <linux/init.h>
	35
	36	#include <asm/system.h>
	37	#include <asm/io.h>
	38	#include <asm/irq.h>
	39
	40	#include "8390.h"
	41
	42	#define DRV_NAME "ac3200"
	43
	44	/* Offsets from the base address. */
	45	#define AC_NIC_BASE 0x00
	46	#define AC_SA_PROM 0x16 /* The station address PROM. */
	47	#define AC_ADDR0 0x00 /* Prefix station address values. */
6aa20a22	48	#define AC_ADDR1 0x40
1da177e4 LT	49	#define AC_ADDR2 0x90
	50	#define AC_ID_PORT 0xC80
	51	#define AC_EISA_ID 0x0110d305
	52	#define AC_RESET_PORT 0xC84
	53	#define AC_RESET 0x00
	54	#define AC_ENABLE 0x01
	55	#define AC_CONFIG 0xC90 /* The configuration port. */
	56
	57	#define AC_IO_EXTENT 0x20
	58	/* Actually accessed is:
	59	* AC_NIC_BASE (0-15)
	60	* AC_SA_PROM (0-5)
	61	* AC_ID_PORT (0-3)
	62	* AC_RESET_PORT
	63	* AC_CONFIG
	64	*/
	65
	66	/* Decoding of the configuration register. */
	67	static unsigned char config2irqmap[8] __initdata = {15, 12, 11, 10, 9, 7, 5, 3};
	68	static int addrmap[8] =
	69	{0xFF0000, 0xFE0000, 0xFD0000, 0xFFF0000, 0xFFE0000, 0xFFC0000, 0xD0000, 0 };
	70	static const char *port_name[4] = { "10baseT", "invalid", "AUI", "10base2"};
	71
	72	#define config2irq(configval) config2irqmap[((configval) >> 3) & 7]
	73	#define config2mem(configval) addrmap[(configval) & 7]
	74	#define config2name(configval) port_name[((configval) >> 6) & 3]
	75
	76	/* First and last 8390 pages. */
	77	#define AC_START_PG 0x00 /* First page of 8390 TX buffer */
	78	#define AC_STOP_PG 0x80 /* Last page +1 of the 8390 RX ring */
	79
	80	static int ac_probe1(int ioaddr, struct net_device *dev);
	81
	82	static int ac_open(struct net_device *dev);
	83	static void ac_reset_8390(struct net_device *dev);
	84	static void ac_block_input(struct net_device *dev, int count,
	85	struct sk_buff *skb, int ring_offset);
	86	static void ac_block_output(struct net_device *dev, const int count,
	87	const unsigned char *buf, const int start_page);
	88	static void ac_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr,
	89	int ring_page);
	90
	91	static int ac_close_card(struct net_device *dev);
6aa20a22	92
1da177e4 LT	93
	94	/* Probe for the AC3200.
	95
	96	The AC3200 can be identified by either the EISA configuration registers,
	97	or the unique value in the station address PROM.
	98	*/
	99
	100	static int __init do_ac3200_probe(struct net_device *dev)
	101	{
	102	unsigned short ioaddr = dev->base_addr;
	103	int irq = dev->irq;
	104	int mem_start = dev->mem_start;
	105
1da177e4 LT	106	if (ioaddr > 0x1ff) /* Check a single specified location. */
	107	return ac_probe1(ioaddr, dev);
	108	else if (ioaddr > 0) /* Don't probe at all. */
	109	return -ENXIO;
	110
	111	if ( ! EISA_bus)
	112	return -ENXIO;
	113
	114	for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
	115	if (ac_probe1(ioaddr, dev) == 0)
	116	return 0;
	117	dev->irq = irq;
	118	dev->mem_start = mem_start;
	119	}
	120
	121	return -ENODEV;
	122	}
	123
1da177e4 LT	124	#ifndef MODULE
	125	struct net_device * __init ac3200_probe(int unit)
	126	{
	127	struct net_device *dev = alloc_ei_netdev();
	128	int err;
	129
	130	if (!dev)
	131	return ERR_PTR(-ENOMEM);
	132
	133	sprintf(dev->name, "eth%d", unit);
	134	netdev_boot_setup_check(dev);
	135
	136	err = do_ac3200_probe(dev);
	137	if (err)
	138	goto out;
1da177e4	139	return dev;
1da177e4 LT	140	out:
	141	free_netdev(dev);
	142	return ERR_PTR(err);
	143	}
	144	#endif
	145
	146	static int __init ac_probe1(int ioaddr, struct net_device *dev)
	147	{
	148	int i, retval;
	149
	150	if (!request_region(ioaddr, AC_IO_EXTENT, DRV_NAME))
	151	return -EBUSY;
	152
	153	if (inb_p(ioaddr + AC_ID_PORT) == 0xff) {
	154	retval = -ENODEV;
	155	goto out;
	156	}
	157
	158	if (inl(ioaddr + AC_ID_PORT) != AC_EISA_ID) {
	159	retval = -ENODEV;
	160	goto out;
	161	}
	162
	163	#ifndef final_version
	164	printk(KERN_DEBUG "AC3200 ethercard configuration register is %#02x,"
	165	" EISA ID %02x %02x %02x %02x.\n", inb(ioaddr + AC_CONFIG),
	166	inb(ioaddr + AC_ID_PORT + 0), inb(ioaddr + AC_ID_PORT + 1),
	167	inb(ioaddr + AC_ID_PORT + 2), inb(ioaddr + AC_ID_PORT + 3));
	168	#endif
	169
	170	printk("AC3200 in EISA slot %d, node", ioaddr/0x1000);
	171	for(i = 0; i < 6; i++)
	172	printk(" %02x", dev->dev_addr[i] = inb(ioaddr + AC_SA_PROM + i));
	173
	174	#if 0
	175	/* Check the vendor ID/prefix. Redundant after checking the EISA ID */
	176	if (inb(ioaddr + AC_SA_PROM + 0) != AC_ADDR0
	177	\|\| inb(ioaddr + AC_SA_PROM + 1) != AC_ADDR1
	178	\|\| inb(ioaddr + AC_SA_PROM + 2) != AC_ADDR2 ) {
	179	printk(", not found (invalid prefix).\n");
	180	retval = -ENODEV;
	181	goto out;
	182	}
	183	#endif
	184
	185	/* Assign and allocate the interrupt now. */
	186	if (dev->irq == 0) {
	187	dev->irq = config2irq(inb(ioaddr + AC_CONFIG));
	188	printk(", using");
	189	} else {
	190	dev->irq = irq_canonicalize(dev->irq);
	191	printk(", assigning");
	192	}
	193
	194	retval = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
	195	if (retval) {
	196	printk (" nothing! Unable to get IRQ %d.\n", dev->irq);
	197	goto out1;
	198	}
	199
	200	printk(" IRQ %d, %s port\n", dev->irq, port_name[dev->if_port]);
	201
	202	dev->base_addr = ioaddr;
	203
204	#ifdef notyet
205	if (dev->mem_start) { /* Override the value from the board. */
206	for (i = 0; i < 7; i++)
207	if (addrmap[i] == dev->mem_start)
208	break;
209	if (i >= 7)
210	i = 0;
211	outb((inb(ioaddr + AC_CONFIG) & ~7) \| i, ioaddr + AC_CONFIG);
212	}
213	#endif
214
215	dev->if_port = inb(ioaddr + AC_CONFIG) >> 6;
216	dev->mem_start = config2mem(inb(ioaddr + AC_CONFIG));
217
6aa20a22	218	printk("%s: AC3200 at %#3x with %dkB memory at physical address %#lx.\n",
1da177e4 LT	219	dev->name, ioaddr, AC_STOP_PG/4, dev->mem_start);
	220
	221	/*
	222	* BEWARE!! Some dain-bramaged EISA SCUs will allow you to put
	223	* the card mem within the region covered by `normal' RAM !!!
	224	*
	225	* ioremap() will fail in that case.
	226	*/
	227	ei_status.mem = ioremap(dev->mem_start, AC_STOP_PG*0x100);
	228	if (!ei_status.mem) {
	229	printk(KERN_ERR "ac3200.c: Unable to remap card memory above 1MB !!\n");
	230	printk(KERN_ERR "ac3200.c: Try using EISA SCU to set memory below 1MB.\n");
	231	printk(KERN_ERR "ac3200.c: Driver NOT installed.\n");
	232	retval = -EINVAL;
	233	goto out1;
	234	}
	235	printk("ac3200.c: remapped %dkB card memory to virtual address %p\n",
	236	AC_STOP_PG/4, ei_status.mem);
	237
	238	dev->mem_start = (unsigned long)ei_status.mem;
	239	dev->mem_end = dev->mem_start + (AC_STOP_PG - AC_START_PG)*256;
	240
	241	ei_status.name = "AC3200";
	242	ei_status.tx_start_page = AC_START_PG;
	243	ei_status.rx_start_page = AC_START_PG + TX_PAGES;
	244	ei_status.stop_page = AC_STOP_PG;
	245	ei_status.word16 = 1;
	246
	247	if (ei_debug > 0)
	248	printk(version);
	249
	250	ei_status.reset_8390 = &ac_reset_8390;
	251	ei_status.block_input = &ac_block_input;
	252	ei_status.block_output = &ac_block_output;
	253	ei_status.get_8390_hdr = &ac_get_8390_hdr;
	254
	255	dev->open = &ac_open;
	256	dev->stop = &ac_close_card;
	257	#ifdef CONFIG_NET_POLL_CONTROLLER
	258	dev->poll_controller = ei_poll;
	259	#endif
	260	NS8390_init(dev, 0);
b1fc5505	261
	262	retval = register_netdev(dev);
	263	if (retval)
	264	goto out2;
1da177e4	265	return 0;
b1fc5505	266	out2:
b1fc5505	267	if (ei_status.reg0)
5ac90037	268	iounmap(ei_status.mem);
1da177e4 LT	269	out1:
	270	free_irq(dev->irq, dev);
	271	out:
	272	release_region(ioaddr, AC_IO_EXTENT);
	273	return retval;
	274	}
	275
	276	static int ac_open(struct net_device *dev)
	277	{
	278	#ifdef notyet
	279	/* Someday we may enable the IRQ and shared memory here. */
	280	int ioaddr = dev->base_addr;
	281	#endif
	282
	283	ei_open(dev);
	284	return 0;
	285	}
	286
	287	static void ac_reset_8390(struct net_device *dev)
	288	{
	289	ushort ioaddr = dev->base_addr;
	290
	291	outb(AC_RESET, ioaddr + AC_RESET_PORT);
	292	if (ei_debug > 1) printk("resetting AC3200, t=%ld...", jiffies);
	293
	294	ei_status.txing = 0;
	295	outb(AC_ENABLE, ioaddr + AC_RESET_PORT);
	296	if (ei_debug > 1) printk("reset done\n");
	297
	298	return;
	299	}
	300
	301	/* Grab the 8390 specific header. Similar to the block_input routine, but
	302	we don't need to be concerned with ring wrap as the header will be at
	303	the start of a page, so we optimize accordingly. */
	304
	305	static void
	306	ac_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr, int ring_page)
	307	{
	308	void __iomem *hdr_start = ei_status.mem + ((ring_page - AC_START_PG)<<8);
	309	memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
	310	}
	311
	312	/* Block input and output are easy on shared memory ethercards, the only
	313	complication is when the ring buffer wraps. */
	314
	315	static void ac_block_input(struct net_device dev, int count, struct sk_buff skb,
	316	int ring_offset)
	317	{
	318	void __iomem start = ei_status.mem + ring_offset - AC_START_PG256;
	319
	320	if (ring_offset + count > AC_STOP_PG*256) {
	321	/* We must wrap the input move. */
	322	int semi_count = AC_STOP_PG*256 - ring_offset;
	323	memcpy_fromio(skb->data, start, semi_count);
	324	count -= semi_count;
	325	memcpy_fromio(skb->data + semi_count,
	326	ei_status.mem + TX_PAGES*256, count);
	327	} else {
4ec03116	328	memcpy_fromio(skb->data, start, count);
1da177e4 LT	329	}
	330	}
	331
	332	static void ac_block_output(struct net_device *dev, int count,
	333	const unsigned char *buf, int start_page)
	334	{
	335	void __iomem *shmem = ei_status.mem + ((start_page - AC_START_PG)<<8);
	336
	337	memcpy_toio(shmem, buf, count);
	338	}
	339
	340	static int ac_close_card(struct net_device *dev)
	341	{
	342	if (ei_debug > 1)
	343	printk("%s: Shutting down ethercard.\n", dev->name);
	344
	345	#ifdef notyet
	346	/* We should someday disable shared memory and interrupts. */
	347	outb(0x00, ioaddr + 6); /* Disable interrupts. */
	348	free_irq(dev->irq, dev);
	349	#endif
	350
	351	ei_close(dev);
	352	return 0;
	353	}
	354
	355	#ifdef MODULE
	356	#define MAX_AC32_CARDS 4 /* Max number of AC32 cards per module */
	357	static struct net_device *dev_ac32[MAX_AC32_CARDS];
	358	static int io[MAX_AC32_CARDS];
	359	static int irq[MAX_AC32_CARDS];
	360	static int mem[MAX_AC32_CARDS];
	361	module_param_array(io, int, NULL, 0);
	362	module_param_array(irq, int, NULL, 0);
	363	module_param_array(mem, int, NULL, 0);
	364	MODULE_PARM_DESC(io, "I/O base address(es)");
	365	MODULE_PARM_DESC(irq, "IRQ number(s)");
	366	MODULE_PARM_DESC(mem, "Memory base address(es)");
	367	MODULE_DESCRIPTION("Ansel AC3200 EISA ethernet driver");
	368	MODULE_LICENSE("GPL");
	369
62a87b80	370	int __init init_module(void)
1da177e4 LT	371	{
	372	struct net_device *dev;
	373	int this_dev, found = 0;
	374
	375	for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) {
	376	if (io[this_dev] == 0 && this_dev != 0)
	377	break;
	378	dev = alloc_ei_netdev();
	379	if (!dev)
	380	break;
	381	dev->irq = irq[this_dev];
	382	dev->base_addr = io[this_dev];
	383	dev->mem_start = mem[this_dev]; /* Currently ignored by driver */
	384	if (do_ac3200_probe(dev) == 0) {
b1fc5505	385	dev_ac32[found++] = dev;
b1fc5505	386	continue;
1da177e4 LT	387	}
	388	free_netdev(dev);
	389	printk(KERN_WARNING "ac3200.c: No ac3200 card found (i/o = 0x%x).\n", io[this_dev]);
	390	break;
	391	}
	392	if (found)
	393	return 0;
	394	return -ENXIO;
	395	}
	396
64916f1e DV	397	static void cleanup_card(struct net_device *dev)
	398	{
	399	/* Someday free_irq may be in ac_close_card() */
	400	free_irq(dev->irq, dev);
	401	release_region(dev->base_addr, AC_IO_EXTENT);
	402	iounmap(ei_status.mem);
	403	}
	404
afc8eb46	405	void __exit
1da177e4 LT	406	cleanup_module(void)
	407	{
	408	int this_dev;
	409
	410	for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) {
	411	struct net_device *dev = dev_ac32[this_dev];
	412	if (dev) {
	413	unregister_netdev(dev);
	414	cleanup_card(dev);
	415	free_netdev(dev);
	416	}
	417	}
	418	}
	419	#endif /* MODULE */