[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 [email protected], 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 [email protected].

	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 ([email protected])\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

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

	printk(KERN_DEBUG "AC3200 in EISA slot %d, node %pM",
	       ioaddr/0x1000, dev->dev_addr);
#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");

static int __init ac3200_module_init(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);
}

static void __exit ac3200_module_exit(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);
		}
	}
}
module_init(ac3200_module_init);
module_exit(ac3200_module_exit);
#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 [email protected], 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 [email protected].
	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 ([email protected])\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
0795af57 JP	170	for (i = 0; i < 6; i++)
0795af57 JP	171	dev->dev_addr[i] = inb(ioaddr + AC_SA_PROM + i);
1da177e4	172
e174961c JB	173	printk(KERN_DEBUG "AC3200 in EISA slot %d, node %pM",
e174961c JB	174	ioaddr/0x1000, dev->dev_addr);
1da177e4 LT	175	#if 0
	176	/* Check the vendor ID/prefix. Redundant after checking the EISA ID */
	177	if (inb(ioaddr + AC_SA_PROM + 0) != AC_ADDR0
	178	\|\| inb(ioaddr + AC_SA_PROM + 1) != AC_ADDR1
	179	\|\| inb(ioaddr + AC_SA_PROM + 2) != AC_ADDR2 ) {
	180	printk(", not found (invalid prefix).\n");
	181	retval = -ENODEV;
	182	goto out;
	183	}
	184	#endif
	185
	186	/* Assign and allocate the interrupt now. */
	187	if (dev->irq == 0) {
	188	dev->irq = config2irq(inb(ioaddr + AC_CONFIG));
	189	printk(", using");
	190	} else {
	191	dev->irq = irq_canonicalize(dev->irq);
	192	printk(", assigning");
	193	}
	194
	195	retval = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
	196	if (retval) {
	197	printk (" nothing! Unable to get IRQ %d.\n", dev->irq);
	198	goto out1;
	199	}
	200
	201	printk(" IRQ %d, %s port\n", dev->irq, port_name[dev->if_port]);
	202
	203	dev->base_addr = ioaddr;
	204
	205	#ifdef notyet
	206	if (dev->mem_start) { /* Override the value from the board. */
	207	for (i = 0; i < 7; i++)
	208	if (addrmap[i] == dev->mem_start)
	209	break;
	210	if (i >= 7)
	211	i = 0;
	212	outb((inb(ioaddr + AC_CONFIG) & ~7) \| i, ioaddr + AC_CONFIG);
	213	}
	214	#endif
	215
	216	dev->if_port = inb(ioaddr + AC_CONFIG) >> 6;
	217	dev->mem_start = config2mem(inb(ioaddr + AC_CONFIG));
	218
6aa20a22	219	printk("%s: AC3200 at %#3x with %dkB memory at physical address %#lx.\n",
1da177e4 LT	220	dev->name, ioaddr, AC_STOP_PG/4, dev->mem_start);
	221
	222	/*
	223	* BEWARE!! Some dain-bramaged EISA SCUs will allow you to put
	224	* the card mem within the region covered by `normal' RAM !!!
	225	*
	226	* ioremap() will fail in that case.
	227	*/
	228	ei_status.mem = ioremap(dev->mem_start, AC_STOP_PG*0x100);
	229	if (!ei_status.mem) {
	230	printk(KERN_ERR "ac3200.c: Unable to remap card memory above 1MB !!\n");
	231	printk(KERN_ERR "ac3200.c: Try using EISA SCU to set memory below 1MB.\n");
	232	printk(KERN_ERR "ac3200.c: Driver NOT installed.\n");
	233	retval = -EINVAL;
	234	goto out1;
	235	}
	236	printk("ac3200.c: remapped %dkB card memory to virtual address %p\n",
	237	AC_STOP_PG/4, ei_status.mem);
	238
	239	dev->mem_start = (unsigned long)ei_status.mem;
	240	dev->mem_end = dev->mem_start + (AC_STOP_PG - AC_START_PG)*256;
	241
	242	ei_status.name = "AC3200";
	243	ei_status.tx_start_page = AC_START_PG;
	244	ei_status.rx_start_page = AC_START_PG + TX_PAGES;
	245	ei_status.stop_page = AC_STOP_PG;
	246	ei_status.word16 = 1;
	247
	248	if (ei_debug > 0)
	249	printk(version);
	250
	251	ei_status.reset_8390 = &ac_reset_8390;
	252	ei_status.block_input = &ac_block_input;
	253	ei_status.block_output = &ac_block_output;
	254	ei_status.get_8390_hdr = &ac_get_8390_hdr;
	255
	256	dev->open = &ac_open;
	257	dev->stop = &ac_close_card;
	258	#ifdef CONFIG_NET_POLL_CONTROLLER
	259	dev->poll_controller = ei_poll;
	260	#endif
	261	NS8390_init(dev, 0);
b1fc5505 HX	262
	263	retval = register_netdev(dev);
	264	if (retval)
	265	goto out2;
1da177e4	266	return 0;
b1fc5505 HX	267	out2:
b1fc5505 HX	268	if (ei_status.reg0)
5ac90037	269	iounmap(ei_status.mem);
1da177e4 LT	270	out1:
	271	free_irq(dev->irq, dev);
	272	out:
	273	release_region(ioaddr, AC_IO_EXTENT);
	274	return retval;
	275	}
	276
	277	static int ac_open(struct net_device *dev)
	278	{
	279	#ifdef notyet
	280	/* Someday we may enable the IRQ and shared memory here. */
	281	int ioaddr = dev->base_addr;
	282	#endif
	283
	284	ei_open(dev);
	285	return 0;
	286	}
	287
	288	static void ac_reset_8390(struct net_device *dev)
	289	{
	290	ushort ioaddr = dev->base_addr;
	291
	292	outb(AC_RESET, ioaddr + AC_RESET_PORT);
	293	if (ei_debug > 1) printk("resetting AC3200, t=%ld...", jiffies);
	294
	295	ei_status.txing = 0;
	296	outb(AC_ENABLE, ioaddr + AC_RESET_PORT);
	297	if (ei_debug > 1) printk("reset done\n");
	298
	299	return;
	300	}
	301
	302	/* Grab the 8390 specific header. Similar to the block_input routine, but
	303	we don't need to be concerned with ring wrap as the header will be at
	304	the start of a page, so we optimize accordingly. */
	305
	306	static void
	307	ac_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr, int ring_page)
	308	{
	309	void __iomem *hdr_start = ei_status.mem + ((ring_page - AC_START_PG)<<8);
	310	memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
	311	}
	312
	313	/* Block input and output are easy on shared memory ethercards, the only
	314	complication is when the ring buffer wraps. */
	315
	316	static void ac_block_input(struct net_device dev, int count, struct sk_buff skb,
	317	int ring_offset)
	318	{
	319	void __iomem start = ei_status.mem + ring_offset - AC_START_PG256;
	320
	321	if (ring_offset + count > AC_STOP_PG*256) {
	322	/* We must wrap the input move. */
	323	int semi_count = AC_STOP_PG*256 - ring_offset;
	324	memcpy_fromio(skb->data, start, semi_count);
	325	count -= semi_count;
	326	memcpy_fromio(skb->data + semi_count,
	327	ei_status.mem + TX_PAGES*256, count);
	328	} else {
4ec03116	329	memcpy_fromio(skb->data, start, count);
1da177e4 LT	330	}
	331	}
	332
	333	static void ac_block_output(struct net_device *dev, int count,
	334	const unsigned char *buf, int start_page)
	335	{
	336	void __iomem *shmem = ei_status.mem + ((start_page - AC_START_PG)<<8);
	337
	338	memcpy_toio(shmem, buf, count);
	339	}
	340
	341	static int ac_close_card(struct net_device *dev)
	342	{
	343	if (ei_debug > 1)
	344	printk("%s: Shutting down ethercard.\n", dev->name);
	345
	346	#ifdef notyet
	347	/* We should someday disable shared memory and interrupts. */
	348	outb(0x00, ioaddr + 6); /* Disable interrupts. */
	349	free_irq(dev->irq, dev);
	350	#endif
	351
	352	ei_close(dev);
	353	return 0;
	354	}
	355
	356	#ifdef MODULE
	357	#define MAX_AC32_CARDS 4 /* Max number of AC32 cards per module */
	358	static struct net_device *dev_ac32[MAX_AC32_CARDS];
	359	static int io[MAX_AC32_CARDS];
	360	static int irq[MAX_AC32_CARDS];
	361	static int mem[MAX_AC32_CARDS];
	362	module_param_array(io, int, NULL, 0);
	363	module_param_array(irq, int, NULL, 0);
	364	module_param_array(mem, int, NULL, 0);
	365	MODULE_PARM_DESC(io, "I/O base address(es)");
	366	MODULE_PARM_DESC(irq, "IRQ number(s)");
	367	MODULE_PARM_DESC(mem, "Memory base address(es)");
	368	MODULE_DESCRIPTION("Ansel AC3200 EISA ethernet driver");
	369	MODULE_LICENSE("GPL");
	370
e8a1d919	371	static int __init ac3200_module_init(void)
1da177e4 LT	372	{
	373	struct net_device *dev;
	374	int this_dev, found = 0;
	375
	376	for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) {
	377	if (io[this_dev] == 0 && this_dev != 0)
	378	break;
	379	dev = alloc_ei_netdev();
	380	if (!dev)
	381	break;
	382	dev->irq = irq[this_dev];
	383	dev->base_addr = io[this_dev];
	384	dev->mem_start = mem[this_dev]; /* Currently ignored by driver */
	385	if (do_ac3200_probe(dev) == 0) {
b1fc5505 HX	386	dev_ac32[found++] = dev;
b1fc5505 HX	387	continue;
1da177e4 LT	388	}
	389	free_netdev(dev);
	390	printk(KERN_WARNING "ac3200.c: No ac3200 card found (i/o = 0x%x).\n", io[this_dev]);
	391	break;
	392	}
	393	if (found)
	394	return 0;
	395	return -ENXIO;
	396	}
	397
64916f1e DV	398	static void cleanup_card(struct net_device *dev)
	399	{
	400	/* Someday free_irq may be in ac_close_card() */
	401	free_irq(dev->irq, dev);
	402	release_region(dev->base_addr, AC_IO_EXTENT);
	403	iounmap(ei_status.mem);
	404	}
	405
e8a1d919	406	static void __exit ac3200_module_exit(void)
1da177e4 LT	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	}
e8a1d919 JS	419	module_init(ac3200_module_init);
e8a1d919 JS	420	module_exit(ac3200_module_exit);
1da177e4	421	#endif /* MODULE */