[net-next-2.6.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 const struct net_device_ops ac_netdev_ops = {
	.ndo_open		= ac_open,
	.ndo_stop 		= ac_close_card,

	.ndo_start_xmit		= ei_start_xmit,
	.ndo_tx_timeout		= ei_tx_timeout,
	.ndo_get_stats		= ei_get_stats,
	.ndo_set_multicast_list = ei_set_multicast_list,
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_set_mac_address 	= eth_mac_addr,
	.ndo_change_mtu		= eth_change_mtu,
#ifdef CONFIG_NET_POLL_CONTROLLER
	.ndo_poll_controller	= ei_poll,
#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 out;
	}

	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->netdev_ops = &ac_netdev_ops;
	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");
}

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