[deliverable/linux.git] / drivers / net / arcnet / com90xx.c

/*
 * Linux ARCnet driver - COM90xx chipset (memory-mapped buffers)
 * 
 * Written 1994-1999 by Avery Pennarun.
 * Written 1999 by Martin Mares <mj@ucw.cz>.
 * Derived from skeleton.c by Donald Becker.
 *
 * Special thanks to Contemporary Controls, Inc. (www.ccontrols.com)
 *  for sponsoring the further development of this driver.
 *
 * **********************
 *
 * The original copyright of skeleton.c was as follows:
 *
 * skeleton.c Written 1993 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.
 *
 * **********************
 *
 * For more details, see drivers/net/arcnet.c
 *
 * **********************
 */
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <linux/delay.h>
#include <linux/netdevice.h>
#include <linux/slab.h>
#include <asm/io.h>
#include <linux/arcdevice.h>


#define VERSION "arcnet: COM90xx chipset support\n"


/* Define this to speed up the autoprobe by assuming if only one io port and
 * shmem are left in the list at Stage 5, they must correspond to each
 * other.
 *
 * This is undefined by default because it might not always be true, and the
 * extra check makes the autoprobe even more careful.  Speed demons can turn
 * it on - I think it should be fine if you only have one ARCnet card
 * installed.
 *
 * If no ARCnet cards are installed, this delay never happens anyway and thus
 * the option has no effect.
 */
#undef FAST_PROBE


/* Internal function declarations */
static int com90xx_found(int ioaddr, int airq, u_long shmem, void __iomem *);
static void com90xx_command(struct net_device *dev, int command);
static int com90xx_status(struct net_device *dev);
static void com90xx_setmask(struct net_device *dev, int mask);
static int com90xx_reset(struct net_device *dev, int really_reset);
static void com90xx_copy_to_card(struct net_device *dev, int bufnum, int offset,
				 void *buf, int count);
static void com90xx_copy_from_card(struct net_device *dev, int bufnum, int offset,
				   void *buf, int count);

/* Known ARCnet cards */

static struct net_device *cards[16];
static int numcards;

/* Handy defines for ARCnet specific stuff */

/* The number of low I/O ports used by the card */
#define ARCNET_TOTAL_SIZE	16

/* Amount of I/O memory used by the card */
#define BUFFER_SIZE (512)
#define MIRROR_SIZE (BUFFER_SIZE*4)

/* COM 9026 controller chip --> ARCnet register addresses */
#define _INTMASK (ioaddr+0)	/* writable */
#define _STATUS  (ioaddr+0)	/* readable */
#define _COMMAND (ioaddr+1)	/* writable, returns random vals on read (?) */
#define _CONFIG  (ioaddr+2)	/* Configuration register */
#define _RESET   (ioaddr+8)	/* software reset (on read) */
#define _MEMDATA (ioaddr+12)	/* Data port for IO-mapped memory */
#define _ADDR_HI (ioaddr+15)	/* Control registers for said */
#define _ADDR_LO (ioaddr+14)

#undef ASTATUS
#undef ACOMMAND
#undef AINTMASK

#define ASTATUS()	inb(_STATUS)
#define ACOMMAND(cmd) 	outb((cmd),_COMMAND)
#define AINTMASK(msk)	outb((msk),_INTMASK)


static int com90xx_skip_probe __initdata = 0;

/* Module parameters */

static int io;			/* use the insmod io= irq= shmem= options */
static int irq;
static int shmem;
static char device[9];		/* use eg. device=arc1 to change name */

module_param(io, int, 0);
module_param(irq, int, 0);
module_param(shmem, int, 0);
module_param_string(device, device, sizeof(device), 0);

static void __init com90xx_probe(void)
{
	int count, status, ioaddr, numprint, airq, openparen = 0;
	unsigned long airqmask;
	int ports[(0x3f0 - 0x200) / 16 + 1] =
	{0};
	unsigned long *shmems;
	void __iomem **iomem;
	int numports, numshmems, *port;
	u_long *p;
	int index;

	if (!io && !irq && !shmem && !*device && com90xx_skip_probe)
		return;

	shmems = kzalloc(((0x100000-0xa0000) / 0x800) * sizeof(unsigned long),
			 GFP_KERNEL);
	if (!shmems)
		return;
	iomem = kzalloc(((0x100000-0xa0000) / 0x800) * sizeof(void __iomem *),
			 GFP_KERNEL);
	if (!iomem) {
		kfree(shmems);
		return;
	}

	BUGLVL(D_NORMAL) printk(VERSION);

	/* set up the arrays where we'll store the possible probe addresses */
	numports = numshmems = 0;
	if (io)
		ports[numports++] = io;
	else
		for (count = 0x200; count <= 0x3f0; count += 16)
			ports[numports++] = count;
	if (shmem)
		shmems[numshmems++] = shmem;
	else
		for (count = 0xA0000; count <= 0xFF800; count += 2048)
			shmems[numshmems++] = count;

	/* Stage 1: abandon any reserved ports, or ones with status==0xFF
	 * (empty), and reset any others by reading the reset port.
	 */
	numprint = -1;
	for (port = &ports[0]; port - ports < numports; port++) {
		numprint++;
		numprint %= 8;
		if (!numprint) {
			BUGMSG2(D_INIT, "\n");
			BUGMSG2(D_INIT, "S1: ");
		}
		BUGMSG2(D_INIT, "%Xh ", *port);

		ioaddr = *port;

		if (!request_region(*port, ARCNET_TOTAL_SIZE, "arcnet (90xx)")) {
			BUGMSG2(D_INIT_REASONS, "(request_region)\n");
			BUGMSG2(D_INIT_REASONS, "S1: ");
			BUGLVL(D_INIT_REASONS) numprint = 0;
			*port-- = ports[--numports];
			continue;
		}
		if (ASTATUS() == 0xFF) {
			BUGMSG2(D_INIT_REASONS, "(empty)\n");
			BUGMSG2(D_INIT_REASONS, "S1: ");
			BUGLVL(D_INIT_REASONS) numprint = 0;
			release_region(*port, ARCNET_TOTAL_SIZE);
			*port-- = ports[--numports];
			continue;
		}
		inb(_RESET);	/* begin resetting card */

		BUGMSG2(D_INIT_REASONS, "\n");
		BUGMSG2(D_INIT_REASONS, "S1: ");
		BUGLVL(D_INIT_REASONS) numprint = 0;
	}
	BUGMSG2(D_INIT, "\n");

	if (!numports) {
		BUGMSG2(D_NORMAL, "S1: No ARCnet cards found.\n");
		kfree(shmems);
		kfree(iomem);
		return;
	}
	/* Stage 2: we have now reset any possible ARCnet cards, so we can't
	 * do anything until they finish.  If D_INIT, print the list of
	 * cards that are left.
	 */
	numprint = -1;
	for (port = &ports[0]; port < ports + numports; port++) {
		numprint++;
		numprint %= 8;
		if (!numprint) {
			BUGMSG2(D_INIT, "\n");
			BUGMSG2(D_INIT, "S2: ");
		}
		BUGMSG2(D_INIT, "%Xh ", *port);
	}
	BUGMSG2(D_INIT, "\n");
	mdelay(RESETtime);

	/* Stage 3: abandon any shmem addresses that don't have the signature
	 * 0xD1 byte in the right place, or are read-only.
	 */
	numprint = -1;
	for (index = 0, p = &shmems[0]; index < numshmems; p++, index++) {
		void __iomem *base;

		numprint++;
		numprint %= 8;
		if (!numprint) {
			BUGMSG2(D_INIT, "\n");
			BUGMSG2(D_INIT, "S3: ");
		}
		BUGMSG2(D_INIT, "%lXh ", *p);

		if (!request_mem_region(*p, MIRROR_SIZE, "arcnet (90xx)")) {
			BUGMSG2(D_INIT_REASONS, "(request_mem_region)\n");
			BUGMSG2(D_INIT_REASONS, "Stage 3: ");
			BUGLVL(D_INIT_REASONS) numprint = 0;
			goto out;
		}
		base = ioremap(*p, MIRROR_SIZE);
		if (!base) {
			BUGMSG2(D_INIT_REASONS, "(ioremap)\n");
			BUGMSG2(D_INIT_REASONS, "Stage 3: ");
			BUGLVL(D_INIT_REASONS) numprint = 0;
			goto out1;
		}
		if (readb(base) != TESTvalue) {
			BUGMSG2(D_INIT_REASONS, "(%02Xh != %02Xh)\n",
				readb(base), TESTvalue);
			BUGMSG2(D_INIT_REASONS, "S3: ");
			BUGLVL(D_INIT_REASONS) numprint = 0;
			goto out2;
		}
		/* By writing 0x42 to the TESTvalue location, we also make
		 * sure no "mirror" shmem areas show up - if they occur
		 * in another pass through this loop, they will be discarded
		 * because *cptr != TESTvalue.
		 */
		writeb(0x42, base);
		if (readb(base) != 0x42) {
			BUGMSG2(D_INIT_REASONS, "(read only)\n");
			BUGMSG2(D_INIT_REASONS, "S3: ");
			goto out2;
		}
		BUGMSG2(D_INIT_REASONS, "\n");
		BUGMSG2(D_INIT_REASONS, "S3: ");
		BUGLVL(D_INIT_REASONS) numprint = 0;
		iomem[index] = base;
		continue;
	out2:
		iounmap(base);
	out1:
		release_mem_region(*p, MIRROR_SIZE);
	out:
		*p-- = shmems[--numshmems];
		index--;
	}
	BUGMSG2(D_INIT, "\n");

	if (!numshmems) {
		BUGMSG2(D_NORMAL, "S3: No ARCnet cards found.\n");
		for (port = &ports[0]; port < ports + numports; port++)
			release_region(*port, ARCNET_TOTAL_SIZE);
		kfree(shmems);
		kfree(iomem);
		return;
	}
	/* Stage 4: something of a dummy, to report the shmems that are
	 * still possible after stage 3.
	 */
	numprint = -1;
	for (p = &shmems[0]; p < shmems + numshmems; p++) {
		numprint++;
		numprint %= 8;
		if (!numprint) {
			BUGMSG2(D_INIT, "\n");
			BUGMSG2(D_INIT, "S4: ");
		}
		BUGMSG2(D_INIT, "%lXh ", *p);
	}
	BUGMSG2(D_INIT, "\n");

	/* Stage 5: for any ports that have the correct status, can disable
	 * the RESET flag, and (if no irq is given) generate an autoirq,
	 * register an ARCnet device.
	 *
	 * Currently, we can only register one device per probe, so quit
	 * after the first one is found.
	 */
	numprint = -1;
	for (port = &ports[0]; port < ports + numports; port++) {
		int found = 0;
		numprint++;
		numprint %= 8;
		if (!numprint) {
			BUGMSG2(D_INIT, "\n");
			BUGMSG2(D_INIT, "S5: ");
		}
		BUGMSG2(D_INIT, "%Xh ", *port);

		ioaddr = *port;
		status = ASTATUS();

		if ((status & 0x9D)
		    != (NORXflag | RECONflag | TXFREEflag | RESETflag)) {
			BUGMSG2(D_INIT_REASONS, "(status=%Xh)\n", status);
			BUGMSG2(D_INIT_REASONS, "S5: ");
			BUGLVL(D_INIT_REASONS) numprint = 0;
			release_region(*port, ARCNET_TOTAL_SIZE);
			*port-- = ports[--numports];
			continue;
		}
		ACOMMAND(CFLAGScmd | RESETclear | CONFIGclear);
		status = ASTATUS();
		if (status & RESETflag) {
			BUGMSG2(D_INIT_REASONS, " (eternal reset, status=%Xh)\n",
				status);
			BUGMSG2(D_INIT_REASONS, "S5: ");
			BUGLVL(D_INIT_REASONS) numprint = 0;
			release_region(*port, ARCNET_TOTAL_SIZE);
			*port-- = ports[--numports];
			continue;
		}
		/* skip this completely if an IRQ was given, because maybe
		 * we're on a machine that locks during autoirq!
		 */
		if (!irq) {
			/* if we do this, we're sure to get an IRQ since the
			 * card has just reset and the NORXflag is on until
			 * we tell it to start receiving.
			 */
			airqmask = probe_irq_on();
			AINTMASK(NORXflag);
			udelay(1);
			AINTMASK(0);
			airq = probe_irq_off(airqmask);

			if (airq <= 0) {
				BUGMSG2(D_INIT_REASONS, "(airq=%d)\n", airq);
				BUGMSG2(D_INIT_REASONS, "S5: ");
				BUGLVL(D_INIT_REASONS) numprint = 0;
				release_region(*port, ARCNET_TOTAL_SIZE);
				*port-- = ports[--numports];
				continue;
			}
		} else {
			airq = irq;
		}

		BUGMSG2(D_INIT, "(%d,", airq);
		openparen = 1;

		/* Everything seems okay.  But which shmem, if any, puts
		 * back its signature byte when the card is reset?
		 *
		 * If there are multiple cards installed, there might be
		 * multiple shmems still in the list.
		 */
#ifdef FAST_PROBE
		if (numports > 1 || numshmems > 1) {
			inb(_RESET);
			mdelay(RESETtime);
		} else {
			/* just one shmem and port, assume they match */
			writeb(TESTvalue, iomem[0]);
		}
#else
		inb(_RESET);
		mdelay(RESETtime);
#endif

		for (index = 0; index < numshmems; index++) {
			u_long ptr = shmems[index];
			void __iomem *base = iomem[index];

			if (readb(base) == TESTvalue) {	/* found one */
				BUGMSG2(D_INIT, "%lXh)\n", *p);
				openparen = 0;

				/* register the card */
				if (com90xx_found(*port, airq, ptr, base) == 0)
					found = 1;
				numprint = -1;

				/* remove shmem from the list */
				shmems[index] = shmems[--numshmems];
				iomem[index] = iomem[numshmems];
				break;	/* go to the next I/O port */
			} else {
				BUGMSG2(D_INIT_REASONS, "%Xh-", readb(base));
			}
		}

		if (openparen) {
			BUGLVL(D_INIT) printk("no matching shmem)\n");
			BUGLVL(D_INIT_REASONS) printk("S5: ");
			BUGLVL(D_INIT_REASONS) numprint = 0;
		}
		if (!found)
			release_region(*port, ARCNET_TOTAL_SIZE);
		*port-- = ports[--numports];
	}

	BUGLVL(D_INIT_REASONS) printk("\n");

	/* Now put back TESTvalue on all leftover shmems. */
	for (index = 0; index < numshmems; index++) {
		writeb(TESTvalue, iomem[index]);
		iounmap(iomem[index]);
		release_mem_region(shmems[index], MIRROR_SIZE);
	}
	kfree(shmems);
	kfree(iomem);
}

static int check_mirror(unsigned long addr, size_t size)
{
	void __iomem *p;
	int res = -1;

	if (!request_mem_region(addr, size, "arcnet (90xx)"))
		return -1;

	p = ioremap(addr, size);
	if (p) {
		if (readb(p) == TESTvalue)
			res = 1;
		else
			res = 0;
		iounmap(p);
	}

	release_mem_region(addr, size);
	return res;
}

/* Set up the struct net_device associated with this card.  Called after
 * probing succeeds.
 */
static int __init com90xx_found(int ioaddr, int airq, u_long shmem, void __iomem *p)
{
	struct net_device *dev = NULL;
	struct arcnet_local *lp;
	u_long first_mirror, last_mirror;
	int mirror_size;

	/* allocate struct net_device */
	dev = alloc_arcdev(device);
	if (!dev) {
		BUGMSG2(D_NORMAL, "com90xx: Can't allocate device!\n");
		iounmap(p);
		release_mem_region(shmem, MIRROR_SIZE);
		return -ENOMEM;
	}
	lp = netdev_priv(dev);
	/* find the real shared memory start/end points, including mirrors */

	/* guess the actual size of one "memory mirror" - the number of
	 * bytes between copies of the shared memory.  On most cards, it's
	 * 2k (or there are no mirrors at all) but on some, it's 4k.
	 */
	mirror_size = MIRROR_SIZE;
	if (readb(p) == TESTvalue &&
	    check_mirror(shmem - MIRROR_SIZE, MIRROR_SIZE) == 0 &&
	    check_mirror(shmem - 2 * MIRROR_SIZE, MIRROR_SIZE) == 1)
		mirror_size = 2 * MIRROR_SIZE;

	first_mirror = shmem - mirror_size;
	while (check_mirror(first_mirror, mirror_size) == 1)
		first_mirror -= mirror_size;
	first_mirror += mirror_size;

	last_mirror = shmem + mirror_size;
	while (check_mirror(last_mirror, mirror_size) == 1)
		last_mirror += mirror_size;
	last_mirror -= mirror_size;

	dev->mem_start = first_mirror;
	dev->mem_end = last_mirror + MIRROR_SIZE - 1;

	iounmap(p);
	release_mem_region(shmem, MIRROR_SIZE);

	if (!request_mem_region(dev->mem_start, dev->mem_end - dev->mem_start + 1, "arcnet (90xx)"))
		goto err_free_dev;

	/* reserve the irq */
	if (request_irq(airq, arcnet_interrupt, 0, "arcnet (90xx)", dev)) {
		BUGMSG(D_NORMAL, "Can't get IRQ %d!\n", airq);
		goto err_release_mem;
	}
	dev->irq = airq;

	/* Initialize the rest of the device structure. */
	lp->card_name = "COM90xx";
	lp->hw.command = com90xx_command;
	lp->hw.status = com90xx_status;
	lp->hw.intmask = com90xx_setmask;
	lp->hw.reset = com90xx_reset;
	lp->hw.owner = THIS_MODULE;
	lp->hw.copy_to_card = com90xx_copy_to_card;
	lp->hw.copy_from_card = com90xx_copy_from_card;
	lp->mem_start = ioremap(dev->mem_start, dev->mem_end - dev->mem_start + 1);
	if (!lp->mem_start) {
		BUGMSG(D_NORMAL, "Can't remap device memory!\n");
		goto err_free_irq;
	}

	/* get and check the station ID from offset 1 in shmem */
	dev->dev_addr[0] = readb(lp->mem_start + 1);

	dev->base_addr = ioaddr;

	BUGMSG(D_NORMAL, "COM90xx station %02Xh found at %03lXh, IRQ %d, "
	       "ShMem %lXh (%ld*%xh).\n",
	       dev->dev_addr[0],
	       dev->base_addr, dev->irq, dev->mem_start,
	 (dev->mem_end - dev->mem_start + 1) / mirror_size, mirror_size);

	if (register_netdev(dev))
		goto err_unmap;

	cards[numcards++] = dev;
	return 0;

err_unmap:
	iounmap(lp->mem_start);
err_free_irq:
	free_irq(dev->irq, dev);
err_release_mem:
	release_mem_region(dev->mem_start, dev->mem_end - dev->mem_start + 1);
err_free_dev:
	free_netdev(dev);
	return -EIO;
}


static void com90xx_command(struct net_device *dev, int cmd)
{
	short ioaddr = dev->base_addr;

	ACOMMAND(cmd);
}


static int com90xx_status(struct net_device *dev)
{
	short ioaddr = dev->base_addr;

	return ASTATUS();
}


static void com90xx_setmask(struct net_device *dev, int mask)
{
	short ioaddr = dev->base_addr;

	AINTMASK(mask);
}


/*
 * Do a hardware reset on the card, and set up necessary registers.
 * 
 * This should be called as little as possible, because it disrupts the
 * token on the network (causes a RECON) and requires a significant delay.
 *
 * However, it does make sure the card is in a defined state.
 */
static int com90xx_reset(struct net_device *dev, int really_reset)
{
	struct arcnet_local *lp = netdev_priv(dev);
	short ioaddr = dev->base_addr;

	BUGMSG(D_INIT, "Resetting (status=%02Xh)\n", ASTATUS());

	if (really_reset) {
		/* reset the card */
		inb(_RESET);
		mdelay(RESETtime);
	}
	ACOMMAND(CFLAGScmd | RESETclear);	/* clear flags & end reset */
	ACOMMAND(CFLAGScmd | CONFIGclear);

	/* don't do this until we verify that it doesn't hurt older cards! */
	/* outb(inb(_CONFIG) | ENABLE16flag, _CONFIG); */

	/* verify that the ARCnet signature byte is present */
	if (readb(lp->mem_start) != TESTvalue) {
		if (really_reset)
			BUGMSG(D_NORMAL, "reset failed: TESTvalue not present.\n");
		return 1;
	}
	/* enable extended (512-byte) packets */
	ACOMMAND(CONFIGcmd | EXTconf);

	/* clean out all the memory to make debugging make more sense :) */
	BUGLVL(D_DURING)
	    memset_io(lp->mem_start, 0x42, 2048);

	/* done!  return success. */
	return 0;
}

static void com90xx_copy_to_card(struct net_device *dev, int bufnum, int offset,
				 void *buf, int count)
{
	struct arcnet_local *lp = netdev_priv(dev);
	void __iomem *memaddr = lp->mem_start + bufnum * 512 + offset;
	TIME("memcpy_toio", count, memcpy_toio(memaddr, buf, count));
}


static void com90xx_copy_from_card(struct net_device *dev, int bufnum, int offset,
				   void *buf, int count)
{
	struct arcnet_local *lp = netdev_priv(dev);
	void __iomem *memaddr = lp->mem_start + bufnum * 512 + offset;
	TIME("memcpy_fromio", count, memcpy_fromio(buf, memaddr, count));
}


MODULE_LICENSE("GPL");

static int __init com90xx_init(void)
{
	if (irq == 2)
		irq = 9;
	com90xx_probe();
	if (!numcards)
		return -EIO;
	return 0;
}

static void __exit com90xx_exit(void)
{
	struct net_device *dev;
	struct arcnet_local *lp;
	int count;

	for (count = 0; count < numcards; count++) {
		dev = cards[count];
		lp = netdev_priv(dev);

		unregister_netdev(dev);
		free_irq(dev->irq, dev);
		iounmap(lp->mem_start);
		release_region(dev->base_addr, ARCNET_TOTAL_SIZE);
		release_mem_region(dev->mem_start, dev->mem_end - dev->mem_start + 1);
		free_netdev(dev);
	}
}

module_init(com90xx_init);
module_exit(com90xx_exit);

#ifndef MODULE
static int __init com90xx_setup(char *s)
{
	int ints[8];

	s = get_options(s, 8, ints);
	if (!ints[0] && !*s) {
		printk("com90xx: Disabled.\n");
		return 1;
	}

	switch (ints[0]) {
	default:		/* ERROR */
		printk("com90xx: Too many arguments.\n");
	case 3:		/* Mem address */
		shmem = ints[3];
	case 2:		/* IRQ */
		irq = ints[2];
	case 1:		/* IO address */
		io = ints[1];
	}

	if (*s)
		snprintf(device, sizeof(device), "%s", s);

	return 1;
}

__setup("com90xx=", com90xx_setup);
#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Linux ARCnet driver - COM90xx chipset (memory-mapped buffers)
	3	*
	4	* Written 1994-1999 by Avery Pennarun.
	5	* Written 1999 by Martin Mares <mj@ucw.cz>.
	6	* Derived from skeleton.c by Donald Becker.
	7	*
	8	* Special thanks to Contemporary Controls, Inc. (www.ccontrols.com)
	9	* for sponsoring the further development of this driver.
	10	*
	11	* **********************
	12	*
	13	* The original copyright of skeleton.c was as follows:
	14	*
	15	* skeleton.c Written 1993 by Donald Becker.
	16	* Copyright 1993 United States Government as represented by the
	17	* Director, National Security Agency. This software may only be used
	18	* and distributed according to the terms of the GNU General Public License as
	19	* modified by SRC, incorporated herein by reference.
	20	*
	21	* **********************
	22	*
	23	* For more details, see drivers/net/arcnet.c
	24	*
	25	* **********************
	26	*/
	27	#include <linux/module.h>
	28	#include <linux/moduleparam.h>
	29	#include <linux/init.h>
a6b7a407	30	#include <linux/interrupt.h>
1da177e4 LT	31	#include <linux/ioport.h>
	32	#include <linux/delay.h>
	33	#include <linux/netdevice.h>
5a0e3ad6	34	#include <linux/slab.h>
1da177e4 LT	35	#include <asm/io.h>
	36	#include <linux/arcdevice.h>
	37
	38
	39	#define VERSION "arcnet: COM90xx chipset support\n"
	40
	41
	42	/* Define this to speed up the autoprobe by assuming if only one io port and
	43	* shmem are left in the list at Stage 5, they must correspond to each
	44	* other.
	45	*
	46	* This is undefined by default because it might not always be true, and the
	47	* extra check makes the autoprobe even more careful. Speed demons can turn
	48	* it on - I think it should be fine if you only have one ARCnet card
	49	* installed.
	50	*
	51	* If no ARCnet cards are installed, this delay never happens anyway and thus
	52	* the option has no effect.
	53	*/
	54	#undef FAST_PROBE
	55
	56
	57	/* Internal function declarations */
d0f6ecad	58	static int com90xx_found(int ioaddr, int airq, u_long shmem, void __iomem *);
1da177e4 LT	59	static void com90xx_command(struct net_device *dev, int command);
	60	static int com90xx_status(struct net_device *dev);
	61	static void com90xx_setmask(struct net_device *dev, int mask);
	62	static int com90xx_reset(struct net_device *dev, int really_reset);
	63	static void com90xx_copy_to_card(struct net_device *dev, int bufnum, int offset,
	64	void *buf, int count);
	65	static void com90xx_copy_from_card(struct net_device *dev, int bufnum, int offset,
	66	void *buf, int count);
	67
	68	/* Known ARCnet cards */
	69
	70	static struct net_device *cards[16];
	71	static int numcards;
	72
	73	/* Handy defines for ARCnet specific stuff */
	74
	75	/* The number of low I/O ports used by the card */
	76	#define ARCNET_TOTAL_SIZE 16
	77
	78	/* Amount of I/O memory used by the card */
	79	#define BUFFER_SIZE (512)
	80	#define MIRROR_SIZE (BUFFER_SIZE*4)
	81
	82	/* COM 9026 controller chip --> ARCnet register addresses */
	83	#define _INTMASK (ioaddr+0) /* writable */
	84	#define _STATUS (ioaddr+0) /* readable */
	85	#define _COMMAND (ioaddr+1) /* writable, returns random vals on read (?) */
	86	#define _CONFIG (ioaddr+2) /* Configuration register */
	87	#define _RESET (ioaddr+8) /* software reset (on read) */
	88	#define _MEMDATA (ioaddr+12) /* Data port for IO-mapped memory */
	89	#define _ADDR_HI (ioaddr+15) /* Control registers for said */
	90	#define _ADDR_LO (ioaddr+14)
	91
	92	#undef ASTATUS
	93	#undef ACOMMAND
	94	#undef AINTMASK
	95
	96	#define ASTATUS() inb(_STATUS)
	97	#define ACOMMAND(cmd) outb((cmd),_COMMAND)
	98	#define AINTMASK(msk) outb((msk),_INTMASK)
	99
	100
	101	static int com90xx_skip_probe __initdata = 0;
	102
	103	/* Module parameters */
	104
	105	static int io; /* use the insmod io= irq= shmem= options */
	106	static int irq;
	107	static int shmem;
	108	static char device[9]; /* use eg. device=arc1 to change name */
	109
	110	module_param(io, int, 0);
	111	module_param(irq, int, 0);
	112	module_param(shmem, int, 0);
	113	module_param_string(device, device, sizeof(device), 0);
	114
	115	static void __init com90xx_probe(void)
	116	{
	117	int count, status, ioaddr, numprint, airq, openparen = 0;
	118	unsigned long airqmask;
	119	int ports[(0x3f0 - 0x200) / 16 + 1] =
	120	{0};
d0f6ecad AV	121	unsigned long *shmems;
d0f6ecad AV	122	void __iomem **iomem;
1da177e4 LT	123	int numports, numshmems, *port;
1da177e4 LT	124	u_long *p;
d0f6ecad	125	int index;
1da177e4 LT	126
	127	if (!io && !irq && !shmem && !*device && com90xx_skip_probe)
	128	return;
	129
15901dc9	130	shmems = kzalloc(((0x100000-0xa0000) / 0x800) * sizeof(unsigned long),
d0f6ecad AV	131	GFP_KERNEL);
	132	if (!shmems)
	133	return;
15901dc9	134	iomem = kzalloc(((0x100000-0xa0000) / 0x800) * sizeof(void __iomem *),
d0f6ecad AV	135	GFP_KERNEL);
	136	if (!iomem) {
	137	kfree(shmems);
	138	return;
	139	}
	140
1da177e4 LT	141	BUGLVL(D_NORMAL) printk(VERSION);
	142
	143	/* set up the arrays where we'll store the possible probe addresses */
	144	numports = numshmems = 0;
	145	if (io)
	146	ports[numports++] = io;
	147	else
	148	for (count = 0x200; count <= 0x3f0; count += 16)
	149	ports[numports++] = count;
	150	if (shmem)
	151	shmems[numshmems++] = shmem;
	152	else
	153	for (count = 0xA0000; count <= 0xFF800; count += 2048)
	154	shmems[numshmems++] = count;
	155
	156	/* Stage 1: abandon any reserved ports, or ones with status==0xFF
	157	* (empty), and reset any others by reading the reset port.
	158	*/
	159	numprint = -1;
	160	for (port = &ports[0]; port - ports < numports; port++) {
	161	numprint++;
	162	numprint %= 8;
	163	if (!numprint) {
	164	BUGMSG2(D_INIT, "\n");
	165	BUGMSG2(D_INIT, "S1: ");
	166	}
	167	BUGMSG2(D_INIT, "%Xh ", *port);
	168
	169	ioaddr = *port;
	170
	171	if (!request_region(*port, ARCNET_TOTAL_SIZE, "arcnet (90xx)")) {
	172	BUGMSG2(D_INIT_REASONS, "(request_region)\n");
	173	BUGMSG2(D_INIT_REASONS, "S1: ");
	174	BUGLVL(D_INIT_REASONS) numprint = 0;
	175	*port-- = ports[--numports];
	176	continue;
	177	}
	178	if (ASTATUS() == 0xFF) {
	179	BUGMSG2(D_INIT_REASONS, "(empty)\n");
	180	BUGMSG2(D_INIT_REASONS, "S1: ");
	181	BUGLVL(D_INIT_REASONS) numprint = 0;
	182	release_region(*port, ARCNET_TOTAL_SIZE);
	183	*port-- = ports[--numports];
	184	continue;
	185	}
	186	inb(_RESET); /* begin resetting card */
	187
	188	BUGMSG2(D_INIT_REASONS, "\n");
	189	BUGMSG2(D_INIT_REASONS, "S1: ");
	190	BUGLVL(D_INIT_REASONS) numprint = 0;
	191	}
	192	BUGMSG2(D_INIT, "\n");
	193
	194	if (!numports) {
	195	BUGMSG2(D_NORMAL, "S1: No ARCnet cards found.\n");
d0f6ecad AV	196	kfree(shmems);
d0f6ecad AV	197	kfree(iomem);
1da177e4 LT	198	return;
	199	}
	200	/* Stage 2: we have now reset any possible ARCnet cards, so we can't
	201	* do anything until they finish. If D_INIT, print the list of
	202	* cards that are left.
	203	*/
	204	numprint = -1;
	205	for (port = &ports[0]; port < ports + numports; port++) {
	206	numprint++;
	207	numprint %= 8;
	208	if (!numprint) {
	209	BUGMSG2(D_INIT, "\n");
	210	BUGMSG2(D_INIT, "S2: ");
	211	}
	212	BUGMSG2(D_INIT, "%Xh ", *port);
	213	}
	214	BUGMSG2(D_INIT, "\n");
	215	mdelay(RESETtime);
	216
	217	/* Stage 3: abandon any shmem addresses that don't have the signature
	218	* 0xD1 byte in the right place, or are read-only.
	219	*/
	220	numprint = -1;
d0f6ecad AV	221	for (index = 0, p = &shmems[0]; index < numshmems; p++, index++) {
d0f6ecad AV	222	void __iomem *base;
1da177e4 LT	223
	224	numprint++;
	225	numprint %= 8;
	226	if (!numprint) {
	227	BUGMSG2(D_INIT, "\n");
	228	BUGMSG2(D_INIT, "S3: ");
	229	}
	230	BUGMSG2(D_INIT, "%lXh ", *p);
	231
d0f6ecad	232	if (!request_mem_region(*p, MIRROR_SIZE, "arcnet (90xx)")) {
1da177e4 LT	233	BUGMSG2(D_INIT_REASONS, "(request_mem_region)\n");
	234	BUGMSG2(D_INIT_REASONS, "Stage 3: ");
	235	BUGLVL(D_INIT_REASONS) numprint = 0;
d0f6ecad AV	236	goto out;
	237	}
	238	base = ioremap(*p, MIRROR_SIZE);
	239	if (!base) {
	240	BUGMSG2(D_INIT_REASONS, "(ioremap)\n");
	241	BUGMSG2(D_INIT_REASONS, "Stage 3: ");
	242	BUGLVL(D_INIT_REASONS) numprint = 0;
	243	goto out1;
1da177e4	244	}
d0f6ecad	245	if (readb(base) != TESTvalue) {
1da177e4	246	BUGMSG2(D_INIT_REASONS, "(%02Xh != %02Xh)\n",
d0f6ecad	247	readb(base), TESTvalue);
1da177e4 LT	248	BUGMSG2(D_INIT_REASONS, "S3: ");
1da177e4 LT	249	BUGLVL(D_INIT_REASONS) numprint = 0;
d0f6ecad	250	goto out2;
1da177e4 LT	251	}
	252	/* By writing 0x42 to the TESTvalue location, we also make
	253	* sure no "mirror" shmem areas show up - if they occur
	254	* in another pass through this loop, they will be discarded
	255	* because *cptr != TESTvalue.
	256	*/
d0f6ecad AV	257	writeb(0x42, base);
d0f6ecad AV	258	if (readb(base) != 0x42) {
1da177e4 LT	259	BUGMSG2(D_INIT_REASONS, "(read only)\n");
1da177e4 LT	260	BUGMSG2(D_INIT_REASONS, "S3: ");
d0f6ecad	261	goto out2;
1da177e4 LT	262	}
	263	BUGMSG2(D_INIT_REASONS, "\n");
	264	BUGMSG2(D_INIT_REASONS, "S3: ");
	265	BUGLVL(D_INIT_REASONS) numprint = 0;
d0f6ecad AV	266	iomem[index] = base;
	267	continue;
	268	out2:
	269	iounmap(base);
	270	out1:
	271	release_mem_region(*p, MIRROR_SIZE);
	272	out:
	273	*p-- = shmems[--numshmems];
	274	index--;
1da177e4 LT	275	}
	276	BUGMSG2(D_INIT, "\n");
	277
	278	if (!numshmems) {
	279	BUGMSG2(D_NORMAL, "S3: No ARCnet cards found.\n");
	280	for (port = &ports[0]; port < ports + numports; port++)
	281	release_region(*port, ARCNET_TOTAL_SIZE);
d0f6ecad AV	282	kfree(shmems);
d0f6ecad AV	283	kfree(iomem);
1da177e4 LT	284	return;
	285	}
	286	/* Stage 4: something of a dummy, to report the shmems that are
	287	* still possible after stage 3.
	288	*/
	289	numprint = -1;
	290	for (p = &shmems[0]; p < shmems + numshmems; p++) {
	291	numprint++;
	292	numprint %= 8;
	293	if (!numprint) {
	294	BUGMSG2(D_INIT, "\n");
	295	BUGMSG2(D_INIT, "S4: ");
	296	}
	297	BUGMSG2(D_INIT, "%lXh ", *p);
	298	}
	299	BUGMSG2(D_INIT, "\n");
	300
	301	/* Stage 5: for any ports that have the correct status, can disable
	302	* the RESET flag, and (if no irq is given) generate an autoirq,
	303	* register an ARCnet device.
	304	*
	305	* Currently, we can only register one device per probe, so quit
	306	* after the first one is found.
	307	*/
	308	numprint = -1;
	309	for (port = &ports[0]; port < ports + numports; port++) {
	310	int found = 0;
	311	numprint++;
	312	numprint %= 8;
	313	if (!numprint) {
	314	BUGMSG2(D_INIT, "\n");
	315	BUGMSG2(D_INIT, "S5: ");
	316	}
	317	BUGMSG2(D_INIT, "%Xh ", *port);
	318
	319	ioaddr = *port;
	320	status = ASTATUS();
	321
	322	if ((status & 0x9D)
	323	!= (NORXflag \| RECONflag \| TXFREEflag \| RESETflag)) {
	324	BUGMSG2(D_INIT_REASONS, "(status=%Xh)\n", status);
	325	BUGMSG2(D_INIT_REASONS, "S5: ");
	326	BUGLVL(D_INIT_REASONS) numprint = 0;
	327	release_region(*port, ARCNET_TOTAL_SIZE);
	328	*port-- = ports[--numports];
	329	continue;
	330	}
	331	ACOMMAND(CFLAGScmd \| RESETclear \| CONFIGclear);
	332	status = ASTATUS();
	333	if (status & RESETflag) {
	334	BUGMSG2(D_INIT_REASONS, " (eternal reset, status=%Xh)\n",
	335	status);
	336	BUGMSG2(D_INIT_REASONS, "S5: ");
	337	BUGLVL(D_INIT_REASONS) numprint = 0;
	338	release_region(*port, ARCNET_TOTAL_SIZE);
	339	*port-- = ports[--numports];
	340	continue;
	341	}
	342	/* skip this completely if an IRQ was given, because maybe
	343	* we're on a machine that locks during autoirq!
	344	*/
	345	if (!irq) {
	346	/* if we do this, we're sure to get an IRQ since the
	347	* card has just reset and the NORXflag is on until
348	* we tell it to start receiving.
349	*/
350	airqmask = probe_irq_on();
351	AINTMASK(NORXflag);
352	udelay(1);
353	AINTMASK(0);
354	airq = probe_irq_off(airqmask);
355
356	if (airq <= 0) {
357	BUGMSG2(D_INIT_REASONS, "(airq=%d)\n", airq);
358	BUGMSG2(D_INIT_REASONS, "S5: ");
359	BUGLVL(D_INIT_REASONS) numprint = 0;
360	release_region(*port, ARCNET_TOTAL_SIZE);
361	*port-- = ports[--numports];
362	continue;
363	}
364	} else {
365	airq = irq;
366	}
367
368	BUGMSG2(D_INIT, "(%d,", airq);
369	openparen = 1;
370
371	/* Everything seems okay. But which shmem, if any, puts
372	* back its signature byte when the card is reset?
373	*
374	* If there are multiple cards installed, there might be
375	* multiple shmems still in the list.
376	*/
377	#ifdef FAST_PROBE
378	if (numports > 1 \|\| numshmems > 1) {
379	inb(_RESET);
380	mdelay(RESETtime);
381	} else {
382	/* just one shmem and port, assume they match */
d0f6ecad	383	writeb(TESTvalue, iomem[0]);
1da177e4 LT	384	}
	385	#else
	386	inb(_RESET);
	387	mdelay(RESETtime);
	388	#endif
	389
d0f6ecad AV	390	for (index = 0; index < numshmems; index++) {
	391	u_long ptr = shmems[index];
	392	void __iomem *base = iomem[index];
1da177e4	393
d0f6ecad	394	if (readb(base) == TESTvalue) { /* found one */
1da177e4 LT	395	BUGMSG2(D_INIT, "%lXh)\n", *p);
	396	openparen = 0;
	397
	398	/* register the card */
d0f6ecad	399	if (com90xx_found(*port, airq, ptr, base) == 0)
1da177e4 LT	400	found = 1;
	401	numprint = -1;
	402
	403	/* remove shmem from the list */
d0f6ecad AV	404	shmems[index] = shmems[--numshmems];
d0f6ecad AV	405	iomem[index] = iomem[numshmems];
1da177e4 LT	406	break; /* go to the next I/O port */
1da177e4 LT	407	} else {
d0f6ecad	408	BUGMSG2(D_INIT_REASONS, "%Xh-", readb(base));
1da177e4 LT	409	}
	410	}
	411
	412	if (openparen) {
	413	BUGLVL(D_INIT) printk("no matching shmem)\n");
	414	BUGLVL(D_INIT_REASONS) printk("S5: ");
	415	BUGLVL(D_INIT_REASONS) numprint = 0;
	416	}
	417	if (!found)
	418	release_region(*port, ARCNET_TOTAL_SIZE);
	419	*port-- = ports[--numports];
	420	}
	421
	422	BUGLVL(D_INIT_REASONS) printk("\n");
	423
	424	/* Now put back TESTvalue on all leftover shmems. */
d0f6ecad AV	425	for (index = 0; index < numshmems; index++) {
	426	writeb(TESTvalue, iomem[index]);
	427	iounmap(iomem[index]);
	428	release_mem_region(shmems[index], MIRROR_SIZE);
1da177e4	429	}
d0f6ecad AV	430	kfree(shmems);
d0f6ecad AV	431	kfree(iomem);
1da177e4 LT	432	}
1da177e4 LT	433
d0f6ecad AV	434	static int check_mirror(unsigned long addr, size_t size)
	435	{
	436	void __iomem *p;
	437	int res = -1;
	438
	439	if (!request_mem_region(addr, size, "arcnet (90xx)"))
	440	return -1;
	441
	442	p = ioremap(addr, size);
	443	if (p) {
	444	if (readb(p) == TESTvalue)
	445	res = 1;
	446	else
	447	res = 0;
	448	iounmap(p);
	449	}
	450
	451	release_mem_region(addr, size);
	452	return res;
	453	}
1da177e4 LT	454
	455	/* Set up the struct net_device associated with this card. Called after
	456	* probing succeeds.
	457	*/
d0f6ecad	458	static int __init com90xx_found(int ioaddr, int airq, u_long shmem, void __iomem *p)
1da177e4 LT	459	{
	460	struct net_device *dev = NULL;
	461	struct arcnet_local *lp;
	462	u_long first_mirror, last_mirror;
	463	int mirror_size;
	464
	465	/* allocate struct net_device */
	466	dev = alloc_arcdev(device);
	467	if (!dev) {
	468	BUGMSG2(D_NORMAL, "com90xx: Can't allocate device!\n");
d0f6ecad AV	469	iounmap(p);
d0f6ecad AV	470	release_mem_region(shmem, MIRROR_SIZE);
1da177e4 LT	471	return -ENOMEM;
1da177e4 LT	472	}
454d7c9b	473	lp = netdev_priv(dev);
1da177e4 LT	474	/* find the real shared memory start/end points, including mirrors */
	475
	476	/* guess the actual size of one "memory mirror" - the number of
	477	* bytes between copies of the shared memory. On most cards, it's
	478	* 2k (or there are no mirrors at all) but on some, it's 4k.
	479	*/
	480	mirror_size = MIRROR_SIZE;
d0f6ecad AV	481	if (readb(p) == TESTvalue &&
	482	check_mirror(shmem - MIRROR_SIZE, MIRROR_SIZE) == 0 &&
	483	check_mirror(shmem - 2 * MIRROR_SIZE, MIRROR_SIZE) == 1)
	484	mirror_size = 2 * MIRROR_SIZE;
1da177e4	485
d0f6ecad AV	486	first_mirror = shmem - mirror_size;
d0f6ecad AV	487	while (check_mirror(first_mirror, mirror_size) == 1)
1da177e4 LT	488	first_mirror -= mirror_size;
	489	first_mirror += mirror_size;
	490
d0f6ecad AV	491	last_mirror = shmem + mirror_size;
d0f6ecad AV	492	while (check_mirror(last_mirror, mirror_size) == 1)
1da177e4 LT	493	last_mirror += mirror_size;
	494	last_mirror -= mirror_size;
	495
	496	dev->mem_start = first_mirror;
	497	dev->mem_end = last_mirror + MIRROR_SIZE - 1;
	498
d0f6ecad AV	499	iounmap(p);
	500	release_mem_region(shmem, MIRROR_SIZE);
	501
1da177e4 LT	502	if (!request_mem_region(dev->mem_start, dev->mem_end - dev->mem_start + 1, "arcnet (90xx)"))
	503	goto err_free_dev;
	504
	505	/* reserve the irq */
a0607fd3	506	if (request_irq(airq, arcnet_interrupt, 0, "arcnet (90xx)", dev)) {
1da177e4 LT	507	BUGMSG(D_NORMAL, "Can't get IRQ %d!\n", airq);
	508	goto err_release_mem;
	509	}
	510	dev->irq = airq;
	511
	512	/* Initialize the rest of the device structure. */
	513	lp->card_name = "COM90xx";
	514	lp->hw.command = com90xx_command;
	515	lp->hw.status = com90xx_status;
	516	lp->hw.intmask = com90xx_setmask;
	517	lp->hw.reset = com90xx_reset;
	518	lp->hw.owner = THIS_MODULE;
	519	lp->hw.copy_to_card = com90xx_copy_to_card;
	520	lp->hw.copy_from_card = com90xx_copy_from_card;
	521	lp->mem_start = ioremap(dev->mem_start, dev->mem_end - dev->mem_start + 1);
	522	if (!lp->mem_start) {
	523	BUGMSG(D_NORMAL, "Can't remap device memory!\n");
	524	goto err_free_irq;
	525	}
	526
	527	/* get and check the station ID from offset 1 in shmem */
	528	dev->dev_addr[0] = readb(lp->mem_start + 1);
	529
	530	dev->base_addr = ioaddr;
	531
	532	BUGMSG(D_NORMAL, "COM90xx station %02Xh found at %03lXh, IRQ %d, "
	533	"ShMem %lXh (%ld*%xh).\n",
	534	dev->dev_addr[0],
	535	dev->base_addr, dev->irq, dev->mem_start,
	536	(dev->mem_end - dev->mem_start + 1) / mirror_size, mirror_size);
	537
	538	if (register_netdev(dev))
	539	goto err_unmap;
	540
	541	cards[numcards++] = dev;
	542	return 0;
	543
	544	err_unmap:
	545	iounmap(lp->mem_start);
	546	err_free_irq:
	547	free_irq(dev->irq, dev);
	548	err_release_mem:
	549	release_mem_region(dev->mem_start, dev->mem_end - dev->mem_start + 1);
	550	err_free_dev:
	551	free_netdev(dev);
	552	return -EIO;
	553	}
	554
	555
	556	static void com90xx_command(struct net_device *dev, int cmd)
	557	{
	558	short ioaddr = dev->base_addr;
	559
	560	ACOMMAND(cmd);
	561	}
	562
	563
	564	static int com90xx_status(struct net_device *dev)
	565	{
	566	short ioaddr = dev->base_addr;
	567
	568	return ASTATUS();
	569	}
	570
571
572	static void com90xx_setmask(struct net_device *dev, int mask)
573	{
574	short ioaddr = dev->base_addr;
575
576	AINTMASK(mask);
577	}
578
579
580	/*
581	* Do a hardware reset on the card, and set up necessary registers.
582	*
583	* This should be called as little as possible, because it disrupts the
584	* token on the network (causes a RECON) and requires a significant delay.
585	*
586	* However, it does make sure the card is in a defined state.
587	*/
888432f6	588	static int com90xx_reset(struct net_device *dev, int really_reset)
1da177e4	589	{
454d7c9b	590	struct arcnet_local *lp = netdev_priv(dev);
1da177e4 LT	591	short ioaddr = dev->base_addr;
	592
	593	BUGMSG(D_INIT, "Resetting (status=%02Xh)\n", ASTATUS());
	594
	595	if (really_reset) {
	596	/* reset the card */
	597	inb(_RESET);
	598	mdelay(RESETtime);
	599	}
	600	ACOMMAND(CFLAGScmd \| RESETclear); /* clear flags & end reset */
	601	ACOMMAND(CFLAGScmd \| CONFIGclear);
	602
	603	/* don't do this until we verify that it doesn't hurt older cards! */
	604	/* outb(inb(_CONFIG) \| ENABLE16flag, _CONFIG); */
	605
	606	/* verify that the ARCnet signature byte is present */
	607	if (readb(lp->mem_start) != TESTvalue) {
	608	if (really_reset)
	609	BUGMSG(D_NORMAL, "reset failed: TESTvalue not present.\n");
	610	return 1;
	611	}
	612	/* enable extended (512-byte) packets */
	613	ACOMMAND(CONFIGcmd \| EXTconf);
	614
	615	/* clean out all the memory to make debugging make more sense :) */
	616	BUGLVL(D_DURING)
	617	memset_io(lp->mem_start, 0x42, 2048);
	618
	619	/* done! return success. */
	620	return 0;
	621	}
	622
	623	static void com90xx_copy_to_card(struct net_device *dev, int bufnum, int offset,
	624	void *buf, int count)
	625	{
454d7c9b	626	struct arcnet_local *lp = netdev_priv(dev);
1da177e4 LT	627	void __iomem memaddr = lp->mem_start + bufnum 512 + offset;
	628	TIME("memcpy_toio", count, memcpy_toio(memaddr, buf, count));
	629	}
	630
	631
	632	static void com90xx_copy_from_card(struct net_device *dev, int bufnum, int offset,
	633	void *buf, int count)
	634	{
454d7c9b	635	struct arcnet_local *lp = netdev_priv(dev);
1da177e4 LT	636	void __iomem memaddr = lp->mem_start + bufnum 512 + offset;
	637	TIME("memcpy_fromio", count, memcpy_fromio(buf, memaddr, count));
	638	}
	639
	640
	641	MODULE_LICENSE("GPL");
	642
	643	static int __init com90xx_init(void)
	644	{
	645	if (irq == 2)
	646	irq = 9;
	647	com90xx_probe();
	648	if (!numcards)
	649	return -EIO;
	650	return 0;
	651	}
	652
	653	static void __exit com90xx_exit(void)
	654	{
	655	struct net_device *dev;
	656	struct arcnet_local *lp;
	657	int count;
	658
	659	for (count = 0; count < numcards; count++) {
	660	dev = cards[count];
454d7c9b	661	lp = netdev_priv(dev);
1da177e4 LT	662
	663	unregister_netdev(dev);
	664	free_irq(dev->irq, dev);
	665	iounmap(lp->mem_start);
	666	release_region(dev->base_addr, ARCNET_TOTAL_SIZE);
	667	release_mem_region(dev->mem_start, dev->mem_end - dev->mem_start + 1);
	668	free_netdev(dev);
	669	}
	670	}
	671
	672	module_init(com90xx_init);
	673	module_exit(com90xx_exit);
	674
	675	#ifndef MODULE
	676	static int __init com90xx_setup(char *s)
	677	{
	678	int ints[8];
	679
	680	s = get_options(s, 8, ints);
	681	if (!ints[0] && !*s) {
	682	printk("com90xx: Disabled.\n");
	683	return 1;
	684	}
	685
	686	switch (ints[0]) {
	687	default: /* ERROR */
	688	printk("com90xx: Too many arguments.\n");
	689	case 3: /* Mem address */
	690	shmem = ints[3];
	691	case 2: /* IRQ */
	692	irq = ints[2];
	693	case 1: /* IO address */
	694	io = ints[1];
	695	}
	696
	697	if (*s)
	698	snprintf(device, sizeof(device), "%s", s);
	699
	700	return 1;
	701	}
	702
	703	__setup("com90xx=", com90xx_setup);
	704	#endif