[mirror_ubuntu-artful-kernel.git] / drivers / net / ethernet / 8390 / wd.c

/* wd.c: A WD80x3 ethernet driver for linux. */
/*
	Written 1993-94 by Donald Becker.

	Copyright 1993 United States Government as represented by the
	Director, National Security Agency.

	This software may be used and distributed according to the terms
	of the GNU General Public License, 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 a driver for WD8003 and WD8013 "compatible" ethercards.

	Thanks to Russ Nelson (nelson@crnwyr.com) for loaning me a WD8013.

	Changelog:

	Paul Gortmaker	: multiple card support for module users, support
			  for non-standard memory sizes.


*/

static const char version[] =
	"wd.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";

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

#include <asm/io.h>

#include "8390.h"

#define DRV_NAME "wd"

/* A zero-terminated list of I/O addresses to be probed. */
static unsigned int wd_portlist[] __initdata =
{0x300, 0x280, 0x380, 0x240, 0};

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

static int wd_open(struct net_device *dev);
static void wd_reset_8390(struct net_device *dev);
static void wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
						int ring_page);
static void wd_block_input(struct net_device *dev, int count,
						  struct sk_buff *skb, int ring_offset);
static void wd_block_output(struct net_device *dev, int count,
							const unsigned char *buf, int start_page);
static int wd_close(struct net_device *dev);

static u32 wd_msg_enable;

#define WD_START_PG		0x00	/* First page of TX buffer */
#define WD03_STOP_PG	0x20	/* Last page +1 of RX ring */
#define WD13_STOP_PG	0x40	/* Last page +1 of RX ring */

#define WD_CMDREG		0		/* Offset to ASIC command register. */
#define	 WD_RESET		0x80	/* Board reset, in WD_CMDREG. */
#define	 WD_MEMENB		0x40	/* Enable the shared memory. */
#define WD_CMDREG5		5		/* Offset to 16-bit-only ASIC register 5. */
#define	 ISA16			0x80	/* Enable 16 bit access from the ISA bus. */
#define	 NIC16			0x40	/* Enable 16 bit access from the 8390. */
#define WD_NIC_OFFSET	16		/* Offset to the 8390 from the base_addr. */
#define WD_IO_EXTENT	32


/*	Probe for the WD8003 and WD8013.  These cards have the station
	address PROM at I/O ports <base>+8 to <base>+13, with a checksum
	following. A Soundblaster can have the same checksum as an WDethercard,
	so we have an extra exclusionary check for it.

	The wd_probe1() routine initializes the card and fills the
	station address field. */

static int __init do_wd_probe(struct net_device *dev)
{
	int i;
	struct resource *r;
	int base_addr = dev->base_addr;
	int irq = dev->irq;
	int mem_start = dev->mem_start;
	int mem_end = dev->mem_end;

	if (base_addr > 0x1ff) {	/* Check a user specified location. */
		r = request_region(base_addr, WD_IO_EXTENT, "wd-probe");
		if ( r == NULL)
			return -EBUSY;
		i = wd_probe1(dev, base_addr);
		if (i != 0)
			release_region(base_addr, WD_IO_EXTENT);
		else
			r->name = dev->name;
		return i;
	}
	else if (base_addr != 0)	/* Don't probe at all. */
		return -ENXIO;

	for (i = 0; wd_portlist[i]; i++) {
		int ioaddr = wd_portlist[i];
		r = request_region(ioaddr, WD_IO_EXTENT, "wd-probe");
		if (r == NULL)
			continue;
		if (wd_probe1(dev, ioaddr) == 0) {
			r->name = dev->name;
			return 0;
		}
		release_region(ioaddr, WD_IO_EXTENT);
		dev->irq = irq;
		dev->mem_start = mem_start;
		dev->mem_end = mem_end;
	}

	return -ENODEV;
}

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

static const struct net_device_ops wd_netdev_ops = {
	.ndo_open		= wd_open,
	.ndo_stop		= wd_close,
	.ndo_start_xmit		= ei_start_xmit,
	.ndo_tx_timeout		= ei_tx_timeout,
	.ndo_get_stats		= ei_get_stats,
	.ndo_set_rx_mode	= ei_set_multicast_list,
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_set_mac_address 	= eth_mac_addr,
#ifdef CONFIG_NET_POLL_CONTROLLER
	.ndo_poll_controller 	= ei_poll,
#endif
};

static int __init wd_probe1(struct net_device *dev, int ioaddr)
{
	int i;
	int err;
	int checksum = 0;
	int ancient = 0;			/* An old card without config registers. */
	int word16 = 0;				/* 0 = 8 bit, 1 = 16 bit */
	const char *model_name;
	static unsigned version_printed;
	struct ei_device *ei_local = netdev_priv(dev);

	for (i = 0; i < 8; i++)
		checksum += inb(ioaddr + 8 + i);
	if (inb(ioaddr + 8) == 0xff 	/* Extra check to avoid soundcard. */
		|| inb(ioaddr + 9) == 0xff
		|| (checksum & 0xff) != 0xFF)
		return -ENODEV;

	/* Check for semi-valid mem_start/end values if supplied. */
	if ((dev->mem_start % 0x2000) || (dev->mem_end % 0x2000)) {
		netdev_warn(dev,
			    "wd.c: user supplied mem_start or mem_end not on 8kB boundary - ignored.\n");
		dev->mem_start = 0;
		dev->mem_end = 0;
	}

	if ((wd_msg_enable & NETIF_MSG_DRV) && (version_printed++ == 0))
		netdev_info(dev, version);

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

	netdev_info(dev, "WD80x3 at %#3x, %pM", ioaddr, dev->dev_addr);

	/* The following PureData probe code was contributed by
	   Mike Jagdis <jaggy@purplet.demon.co.uk>. Puredata does software
	   configuration differently from others so we have to check for them.
	   This detects an 8 bit, 16 bit or dumb (Toshiba, jumpered) card.
	   */
	if (inb(ioaddr+0) == 'P' && inb(ioaddr+1) == 'D') {
		unsigned char reg5 = inb(ioaddr+5);

		switch (inb(ioaddr+2)) {
		case 0x03: word16 = 0; model_name = "PDI8023-8";	break;
		case 0x05: word16 = 0; model_name = "PDUC8023";	break;
		case 0x0a: word16 = 1; model_name = "PDI8023-16"; break;
			/* Either 0x01 (dumb) or they've released a new version. */
		default:	 word16 = 0; model_name = "PDI8023";	break;
		}
		dev->mem_start = ((reg5 & 0x1c) + 0xc0) << 12;
		dev->irq = (reg5 & 0xe0) == 0xe0 ? 10 : (reg5 >> 5) + 1;
	} else {								/* End of PureData probe */
		/* This method of checking for a 16-bit board is borrowed from the
		   we.c driver.  A simpler method is just to look in ASIC reg. 0x03.
		   I'm comparing the two method in alpha test to make certain they
		   return the same result. */
		/* Check for the old 8 bit board - it has register 0/8 aliasing.
		   Do NOT check i>=6 here -- it hangs the old 8003 boards! */
		for (i = 0; i < 6; i++)
			if (inb(ioaddr+i) != inb(ioaddr+8+i))
				break;
		if (i >= 6) {
			ancient = 1;
			model_name = "WD8003-old";
			word16 = 0;
		} else {
			int tmp = inb(ioaddr+1); /* fiddle with 16bit bit */
			outb( tmp ^ 0x01, ioaddr+1 ); /* attempt to clear 16bit bit */
			if (((inb( ioaddr+1) & 0x01) == 0x01) /* A 16 bit card */
				&& (tmp & 0x01) == 0x01	) {				/* In a 16 slot. */
				int asic_reg5 = inb(ioaddr+WD_CMDREG5);
				/* Magic to set ASIC to word-wide mode. */
				outb( NIC16 | (asic_reg5&0x1f), ioaddr+WD_CMDREG5);
				outb(tmp, ioaddr+1);
				model_name = "WD8013";
				word16 = 1;		/* We have a 16bit board here! */
			} else {
				model_name = "WD8003";
				word16 = 0;
			}
			outb(tmp, ioaddr+1);			/* Restore original reg1 value. */
		}
#ifndef final_version
		if ( !ancient && (inb(ioaddr+1) & 0x01) != (word16 & 0x01))
			pr_cont("\nWD80?3: Bus width conflict, %d (probe) != %d (reg report).",
				word16 ? 16 : 8,
				(inb(ioaddr+1) & 0x01) ? 16 : 8);
#endif
	}

#if defined(WD_SHMEM) && WD_SHMEM > 0x80000
	/* Allow a compile-time override.	 */
	dev->mem_start = WD_SHMEM;
#else
	if (dev->mem_start == 0) {
		/* Sanity and old 8003 check */
		int reg0 = inb(ioaddr);
		if (reg0 == 0xff || reg0 == 0) {
			/* Future plan: this could check a few likely locations first. */
			dev->mem_start = 0xd0000;
			pr_cont(" assigning address %#lx", dev->mem_start);
		} else {
			int high_addr_bits = inb(ioaddr+WD_CMDREG5) & 0x1f;
			/* Some boards don't have the register 5 -- it returns 0xff. */
			if (high_addr_bits == 0x1f || word16 == 0)
				high_addr_bits = 0x01;
			dev->mem_start = ((reg0&0x3f) << 13) + (high_addr_bits << 19);
		}
	}
#endif

	/* The 8390 isn't at the base address -- the ASIC regs are there! */
	dev->base_addr = ioaddr+WD_NIC_OFFSET;

	if (dev->irq < 2) {
		static const int irqmap[] = {9, 3, 5, 7, 10, 11, 15, 4};
		int reg1 = inb(ioaddr+1);
		int reg4 = inb(ioaddr+4);
		if (ancient || reg1 == 0xff) {	/* Ack!! No way to read the IRQ! */
			short nic_addr = ioaddr+WD_NIC_OFFSET;
			unsigned long irq_mask;

			/* We have an old-style ethercard that doesn't report its IRQ
			   line.  Do autoirq to find the IRQ line. Note that this IS NOT
			   a reliable way to trigger an interrupt. */
			outb_p(E8390_NODMA + E8390_STOP, nic_addr);
			outb(0x00, nic_addr+EN0_IMR);	/* Disable all intrs. */

			irq_mask = probe_irq_on();
			outb_p(0xff, nic_addr + EN0_IMR);	/* Enable all interrupts. */
			outb_p(0x00, nic_addr + EN0_RCNTLO);
			outb_p(0x00, nic_addr + EN0_RCNTHI);
			outb(E8390_RREAD+E8390_START, nic_addr); /* Trigger it... */
			mdelay(20);
			dev->irq = probe_irq_off(irq_mask);

			outb_p(0x00, nic_addr+EN0_IMR);	/* Mask all intrs. again. */

			if (netif_msg_drv(ei_local))
				pr_cont(" autoirq is %d", dev->irq);
			if (dev->irq < 2)
				dev->irq = word16 ? 10 : 5;
		} else
			dev->irq = irqmap[((reg4 >> 5) & 0x03) + (reg1 & 0x04)];
	} else if (dev->irq == 2)		/* Fixup bogosity: IRQ2 is really IRQ9 */
		dev->irq = 9;

	/* Snarf the interrupt now.  There's no point in waiting since we cannot
	   share and the board will usually be enabled. */
	i = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
	if (i) {
		pr_cont(" unable to get IRQ %d.\n", dev->irq);
		return i;
	}

	/* OK, were are certain this is going to work.  Setup the device. */
	ei_status.name = model_name;
	ei_status.word16 = word16;
	ei_status.tx_start_page = WD_START_PG;
	ei_status.rx_start_page = WD_START_PG + TX_PAGES;

	/* Don't map in the shared memory until the board is actually opened. */

	/* Some cards (eg WD8003EBT) can be jumpered for more (32k!) memory. */
	if (dev->mem_end != 0) {
		ei_status.stop_page = (dev->mem_end - dev->mem_start)/256;
		ei_status.priv = dev->mem_end - dev->mem_start;
	} else {
		ei_status.stop_page = word16 ? WD13_STOP_PG : WD03_STOP_PG;
		dev->mem_end = dev->mem_start + (ei_status.stop_page - WD_START_PG)*256;
		ei_status.priv = (ei_status.stop_page - WD_START_PG)*256;
	}

	ei_status.mem = ioremap(dev->mem_start, ei_status.priv);
	if (!ei_status.mem) {
		free_irq(dev->irq, dev);
		return -ENOMEM;
	}

	pr_cont(" %s, IRQ %d, shared memory at %#lx-%#lx.\n",
		model_name, dev->irq, dev->mem_start, dev->mem_end-1);

	ei_status.reset_8390 = wd_reset_8390;
	ei_status.block_input = wd_block_input;
	ei_status.block_output = wd_block_output;
	ei_status.get_8390_hdr = wd_get_8390_hdr;

	dev->netdev_ops = &wd_netdev_ops;
	NS8390_init(dev, 0);
	ei_local->msg_enable = wd_msg_enable;

#if 1
	/* Enable interrupt generation on softconfig cards -- M.U */
	/* .. but possibly potentially unsafe - Donald */
	if (inb(ioaddr+14) & 0x20)
		outb(inb(ioaddr+4)|0x80, ioaddr+4);
#endif

	err = register_netdev(dev);
	if (err) {
		free_irq(dev->irq, dev);
		iounmap(ei_status.mem);
	}
	return err;
}

static int
wd_open(struct net_device *dev)
{
  int ioaddr = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */

  /* Map in the shared memory. Always set register 0 last to remain
	 compatible with very old boards. */
  ei_status.reg0 = ((dev->mem_start>>13) & 0x3f) | WD_MEMENB;
  ei_status.reg5 = ((dev->mem_start>>19) & 0x1f) | NIC16;

  if (ei_status.word16)
	  outb(ei_status.reg5, ioaddr+WD_CMDREG5);
  outb(ei_status.reg0, ioaddr); /* WD_CMDREG */

  return ei_open(dev);
}

static void
wd_reset_8390(struct net_device *dev)
{
	int wd_cmd_port = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
	struct ei_device *ei_local = netdev_priv(dev);

	outb(WD_RESET, wd_cmd_port);
	netif_dbg(ei_local, hw, dev, "resetting the WD80x3 t=%lu...\n",
		  jiffies);
	ei_status.txing = 0;

	/* Set up the ASIC registers, just in case something changed them. */
	outb((((dev->mem_start>>13) & 0x3f)|WD_MEMENB), wd_cmd_port);
	if (ei_status.word16)
		outb(NIC16 | ((dev->mem_start>>19) & 0x1f), wd_cmd_port+WD_CMDREG5);

	netif_dbg(ei_local, hw, dev, "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
wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
{

	int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
	void __iomem *hdr_start = ei_status.mem + ((ring_page - WD_START_PG)<<8);

	/* We'll always get a 4 byte header read followed by a packet read, so
	   we enable 16 bit mode before the header, and disable after the body. */
	if (ei_status.word16)
		outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);

#ifdef __BIG_ENDIAN
	/* Officially this is what we are doing, but the readl() is faster */
	/* unfortunately it isn't endian aware of the struct               */
	memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
	hdr->count = le16_to_cpu(hdr->count);
#else
	((unsigned int*)hdr)[0] = readl(hdr_start);
#endif
}

/* Block input and output are easy on shared memory ethercards, and trivial
   on the Western digital card where there is no choice of how to do it.
   The only complications are that the ring buffer wraps, and need to map
   switch between 8- and 16-bit modes. */

static void
wd_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
{
	int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
	unsigned long offset = ring_offset - (WD_START_PG<<8);
	void __iomem *xfer_start = ei_status.mem + offset;

	if (offset + count > ei_status.priv) {
		/* We must wrap the input move. */
		int semi_count = ei_status.priv - offset;
		memcpy_fromio(skb->data, xfer_start, semi_count);
		count -= semi_count;
		memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
	} else {
		/* Packet is in one chunk -- we can copy + cksum. */
		memcpy_fromio(skb->data, xfer_start, count);
	}

	/* Turn off 16 bit access so that reboot works.	 ISA brain-damage */
	if (ei_status.word16)
		outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
}

static void
wd_block_output(struct net_device *dev, int count, const unsigned char *buf,
				int start_page)
{
	int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
	void __iomem *shmem = ei_status.mem + ((start_page - WD_START_PG)<<8);


	if (ei_status.word16) {
		/* Turn on and off 16 bit access so that reboot works. */
		outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
		memcpy_toio(shmem, buf, count);
		outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
	} else
		memcpy_toio(shmem, buf, count);
}


static int
wd_close(struct net_device *dev)
{
	int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
	struct ei_device *ei_local = netdev_priv(dev);

	netif_dbg(ei_local, ifdown, dev, "Shutting down ethercard.\n");
	ei_close(dev);

	/* Change from 16-bit to 8-bit shared memory so reboot works. */
	if (ei_status.word16)
		outb(ei_status.reg5, wd_cmdreg + WD_CMDREG5 );

	/* And disable the shared memory. */
	outb(ei_status.reg0 & ~WD_MEMENB, wd_cmdreg);

	return 0;
}


#ifdef MODULE
#define MAX_WD_CARDS	4	/* Max number of wd cards per module */
static struct net_device *dev_wd[MAX_WD_CARDS];
static int io[MAX_WD_CARDS];
static int irq[MAX_WD_CARDS];
static int mem[MAX_WD_CARDS];
static int mem_end[MAX_WD_CARDS];	/* for non std. mem size */

module_param_hw_array(io, int, ioport, NULL, 0);
module_param_hw_array(irq, int, irq, NULL, 0);
module_param_hw_array(mem, int, iomem, NULL, 0);
module_param_hw_array(mem_end, int, iomem, NULL, 0);
module_param_named(msg_enable, wd_msg_enable, uint, (S_IRUSR|S_IRGRP|S_IROTH));
MODULE_PARM_DESC(io, "I/O base address(es)");
MODULE_PARM_DESC(irq, "IRQ number(s) (ignored for PureData boards)");
MODULE_PARM_DESC(mem, "memory base address(es)(ignored for PureData boards)");
MODULE_PARM_DESC(mem_end, "memory end address(es)");
MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)");
MODULE_DESCRIPTION("ISA Western Digital wd8003/wd8013 ; SMC Elite, Elite16 ethernet driver");
MODULE_LICENSE("GPL");

/* This is set up so that only a single autoprobe takes place per call.
ISA device autoprobes on a running machine are not recommended. */

int __init init_module(void)
{
	struct net_device *dev;
	int this_dev, found = 0;

	for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
		if (io[this_dev] == 0)  {
			if (this_dev != 0) break; /* only autoprobe 1st one */
			printk(KERN_NOTICE "wd.c: Presently autoprobing (not recommended) for a single card.\n");
		}
		dev = alloc_ei_netdev();
		if (!dev)
			break;
		dev->irq = irq[this_dev];
		dev->base_addr = io[this_dev];
		dev->mem_start = mem[this_dev];
		dev->mem_end = mem_end[this_dev];
		if (do_wd_probe(dev) == 0) {
			dev_wd[found++] = dev;
			continue;
		}
		free_netdev(dev);
		printk(KERN_WARNING "wd.c: No wd80x3 card found (i/o = 0x%x).\n", io[this_dev]);
		break;
	}
	if (found)
		return 0;
	return -ENXIO;
}

static void cleanup_card(struct net_device *dev)
{
	free_irq(dev->irq, dev);
	release_region(dev->base_addr - WD_NIC_OFFSET, WD_IO_EXTENT);
	iounmap(ei_status.mem);
}

void __exit
cleanup_module(void)
{
	int this_dev;

	for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
		struct net_device *dev = dev_wd[this_dev];
		if (dev) {
			unregister_netdev(dev);
			cleanup_card(dev);
			free_netdev(dev);
		}
	}
}
#endif /* MODULE */
Commit	Line	Data
1da177e4 LT	1	/* wd.c: A WD80x3 ethernet driver for linux. */
	2	/*
	3	Written 1993-94 by Donald Becker.
	4
	5	Copyright 1993 United States Government as represented by the
	6	Director, National Security Agency.
	7
	8	This software may be used and distributed according to the terms
	9	of the GNU General Public License, incorporated herein by reference.
	10
	11	The author may be reached as becker@scyld.com, or C/O
	12	Scyld Computing Corporation
	13	410 Severn Ave., Suite 210
	14	Annapolis MD 21403
	15
	16	This is a driver for WD8003 and WD8013 "compatible" ethercards.
	17
	18	Thanks to Russ Nelson (nelson@crnwyr.com) for loaning me a WD8013.
	19
	20	Changelog:
	21
	22	Paul Gortmaker : multiple card support for module users, support
	23	for non-standard memory sizes.
	24
	25
	26	*/
	27
	28	static const char version[] =
	29	"wd.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
	30
	31	#include <linux/module.h>
	32	#include <linux/kernel.h>
	33	#include <linux/errno.h>
	34	#include <linux/string.h>
	35	#include <linux/init.h>
	36	#include <linux/interrupt.h>
	37	#include <linux/delay.h>
	38	#include <linux/netdevice.h>
	39	#include <linux/etherdevice.h>
	40
	41	#include <asm/io.h>
1da177e4 LT	42
	43	#include "8390.h"
	44
	45	#define DRV_NAME "wd"
	46
	47	/* A zero-terminated list of I/O addresses to be probed. */
	48	static unsigned int wd_portlist[] __initdata =
	49	{0x300, 0x280, 0x380, 0x240, 0};
	50
	51	static int wd_probe1(struct net_device *dev, int ioaddr);
	52
	53	static int wd_open(struct net_device *dev);
	54	static void wd_reset_8390(struct net_device *dev);
	55	static void wd_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr,
	56	int ring_page);
	57	static void wd_block_input(struct net_device *dev, int count,
	58	struct sk_buff *skb, int ring_offset);
	59	static void wd_block_output(struct net_device *dev, int count,
	60	const unsigned char *buf, int start_page);
	61	static int wd_close(struct net_device *dev);
	62
c45f812f	63	static u32 wd_msg_enable;
6aa20a22	64
1da177e4 LT	65	#define WD_START_PG 0x00 /* First page of TX buffer */
	66	#define WD03_STOP_PG 0x20 /* Last page +1 of RX ring */
	67	#define WD13_STOP_PG 0x40 /* Last page +1 of RX ring */
	68
	69	#define WD_CMDREG 0 /* Offset to ASIC command register. */
	70	#define WD_RESET 0x80 /* Board reset, in WD_CMDREG. */
	71	#define WD_MEMENB 0x40 /* Enable the shared memory. */
	72	#define WD_CMDREG5 5 /* Offset to 16-bit-only ASIC register 5. */
	73	#define ISA16 0x80 /* Enable 16 bit access from the ISA bus. */
	74	#define NIC16 0x40 /* Enable 16 bit access from the 8390. */
	75	#define WD_NIC_OFFSET 16 /* Offset to the 8390 from the base_addr. */
	76	#define WD_IO_EXTENT 32
	77
6aa20a22	78
1da177e4 LT	79	/* Probe for the WD8003 and WD8013. These cards have the station
	80	address PROM at I/O ports <base>+8 to <base>+13, with a checksum
	81	following. A Soundblaster can have the same checksum as an WDethercard,
	82	so we have an extra exclusionary check for it.
	83
	84	The wd_probe1() routine initializes the card and fills the
	85	station address field. */
	86
	87	static int __init do_wd_probe(struct net_device *dev)
	88	{
	89	int i;
	90	struct resource *r;
	91	int base_addr = dev->base_addr;
	92	int irq = dev->irq;
	93	int mem_start = dev->mem_start;
	94	int mem_end = dev->mem_end;
	95
1da177e4 LT	96	if (base_addr > 0x1ff) { /* Check a user specified location. */
	97	r = request_region(base_addr, WD_IO_EXTENT, "wd-probe");
	98	if ( r == NULL)
	99	return -EBUSY;
	100	i = wd_probe1(dev, base_addr);
6aa20a22	101	if (i != 0)
1da177e4 LT	102	release_region(base_addr, WD_IO_EXTENT);
	103	else
	104	r->name = dev->name;
	105	return i;
	106	}
	107	else if (base_addr != 0) /* Don't probe at all. */
	108	return -ENXIO;
	109
	110	for (i = 0; wd_portlist[i]; i++) {
	111	int ioaddr = wd_portlist[i];
	112	r = request_region(ioaddr, WD_IO_EXTENT, "wd-probe");
	113	if (r == NULL)
	114	continue;
	115	if (wd_probe1(dev, ioaddr) == 0) {
	116	r->name = dev->name;
	117	return 0;
	118	}
	119	release_region(ioaddr, WD_IO_EXTENT);
	120	dev->irq = irq;
	121	dev->mem_start = mem_start;
	122	dev->mem_end = mem_end;
	123	}
	124
	125	return -ENODEV;
	126	}
	127
1da177e4 LT	128	#ifndef MODULE
	129	struct net_device * __init wd_probe(int unit)
	130	{
	131	struct net_device *dev = alloc_ei_netdev();
	132	int err;
	133
	134	if (!dev)
	135	return ERR_PTR(-ENOMEM);
	136
	137	sprintf(dev->name, "eth%d", unit);
	138	netdev_boot_setup_check(dev);
	139
	140	err = do_wd_probe(dev);
	141	if (err)
	142	goto out;
1da177e4	143	return dev;
1da177e4 LT	144	out:
	145	free_netdev(dev);
	146	return ERR_PTR(err);
	147	}
	148	#endif
	149
458228bc SH	150	static const struct net_device_ops wd_netdev_ops = {
	151	.ndo_open = wd_open,
	152	.ndo_stop = wd_close,
	153	.ndo_start_xmit = ei_start_xmit,
	154	.ndo_tx_timeout = ei_tx_timeout,
	155	.ndo_get_stats = ei_get_stats,
afc4b13d	156	.ndo_set_rx_mode = ei_set_multicast_list,
458228bc	157	.ndo_validate_addr = eth_validate_addr,
fe96aaa1	158	.ndo_set_mac_address = eth_mac_addr,
458228bc SH	159	#ifdef CONFIG_NET_POLL_CONTROLLER
	160	.ndo_poll_controller = ei_poll,
	161	#endif
	162	};
	163
1da177e4 LT	164	static int __init wd_probe1(struct net_device *dev, int ioaddr)
	165	{
	166	int i;
b1fc5505	167	int err;
1da177e4 LT	168	int checksum = 0;
	169	int ancient = 0; /* An old card without config registers. */
	170	int word16 = 0; /* 0 = 8 bit, 1 = 16 bit */
	171	const char *model_name;
	172	static unsigned version_printed;
c45f812f	173	struct ei_device *ei_local = netdev_priv(dev);
1da177e4 LT	174
	175	for (i = 0; i < 8; i++)
	176	checksum += inb(ioaddr + 8 + i);
	177	if (inb(ioaddr + 8) == 0xff /* Extra check to avoid soundcard. */
	178	\|\| inb(ioaddr + 9) == 0xff
	179	\|\| (checksum & 0xff) != 0xFF)
	180	return -ENODEV;
	181
	182	/* Check for semi-valid mem_start/end values if supplied. */
	183	if ((dev->mem_start % 0x2000) \|\| (dev->mem_end % 0x2000)) {
c45f812f MW	184	netdev_warn(dev,
c45f812f MW	185	"wd.c: user supplied mem_start or mem_end not on 8kB boundary - ignored.\n");
1da177e4 LT	186	dev->mem_start = 0;
	187	dev->mem_end = 0;
	188	}
	189
c45f812f MW	190	if ((wd_msg_enable & NETIF_MSG_DRV) && (version_printed++ == 0))
c45f812f MW	191	netdev_info(dev, version);
1da177e4	192
1da177e4	193	for (i = 0; i < 6; i++)
0795af57 JP	194	dev->dev_addr[i] = inb(ioaddr + 8 + i);
0795af57 JP	195
c45f812f	196	netdev_info(dev, "WD80x3 at %#3x, %pM", ioaddr, dev->dev_addr);
1da177e4 LT	197
	198	/* The following PureData probe code was contributed by
	199	Mike Jagdis <jaggy@purplet.demon.co.uk>. Puredata does software
	200	configuration differently from others so we have to check for them.
	201	This detects an 8 bit, 16 bit or dumb (Toshiba, jumpered) card.
	202	*/
	203	if (inb(ioaddr+0) == 'P' && inb(ioaddr+1) == 'D') {
	204	unsigned char reg5 = inb(ioaddr+5);
	205
	206	switch (inb(ioaddr+2)) {
	207	case 0x03: word16 = 0; model_name = "PDI8023-8"; break;
	208	case 0x05: word16 = 0; model_name = "PDUC8023"; break;
	209	case 0x0a: word16 = 1; model_name = "PDI8023-16"; break;
	210	/* Either 0x01 (dumb) or they've released a new version. */
	211	default: word16 = 0; model_name = "PDI8023"; break;
	212	}
	213	dev->mem_start = ((reg5 & 0x1c) + 0xc0) << 12;
	214	dev->irq = (reg5 & 0xe0) == 0xe0 ? 10 : (reg5 >> 5) + 1;
	215	} else { /* End of PureData probe */
	216	/* This method of checking for a 16-bit board is borrowed from the
	217	we.c driver. A simpler method is just to look in ASIC reg. 0x03.
	218	I'm comparing the two method in alpha test to make certain they
	219	return the same result. */
	220	/* Check for the old 8 bit board - it has register 0/8 aliasing.
	221	Do NOT check i>=6 here -- it hangs the old 8003 boards! */
	222	for (i = 0; i < 6; i++)
	223	if (inb(ioaddr+i) != inb(ioaddr+8+i))
	224	break;
	225	if (i >= 6) {
	226	ancient = 1;
	227	model_name = "WD8003-old";
	228	word16 = 0;
	229	} else {
	230	int tmp = inb(ioaddr+1); /* fiddle with 16bit bit */
	231	outb( tmp ^ 0x01, ioaddr+1 ); /* attempt to clear 16bit bit */
	232	if (((inb( ioaddr+1) & 0x01) == 0x01) /* A 16 bit card */
	233	&& (tmp & 0x01) == 0x01 ) { /* In a 16 slot. */
	234	int asic_reg5 = inb(ioaddr+WD_CMDREG5);
	235	/* Magic to set ASIC to word-wide mode. */
	236	outb( NIC16 \| (asic_reg5&0x1f), ioaddr+WD_CMDREG5);
	237	outb(tmp, ioaddr+1);
	238	model_name = "WD8013";
	239	word16 = 1; /* We have a 16bit board here! */
	240	} else {
	241	model_name = "WD8003";
	242	word16 = 0;
	243	}
	244	outb(tmp, ioaddr+1); /* Restore original reg1 value. */
	245	}
	246	#ifndef final_version
	247	if ( !ancient && (inb(ioaddr+1) & 0x01) != (word16 & 0x01))
c45f812f MW	248	pr_cont("\nWD80?3: Bus width conflict, %d (probe) != %d (reg report).",
	249	word16 ? 16 : 8,
	250	(inb(ioaddr+1) & 0x01) ? 16 : 8);
1da177e4 LT	251	#endif
	252	}
	253
	254	#if defined(WD_SHMEM) && WD_SHMEM > 0x80000
	255	/* Allow a compile-time override. */
	256	dev->mem_start = WD_SHMEM;
	257	#else
	258	if (dev->mem_start == 0) {
	259	/* Sanity and old 8003 check */
	260	int reg0 = inb(ioaddr);
	261	if (reg0 == 0xff \|\| reg0 == 0) {
	262	/* Future plan: this could check a few likely locations first. */
	263	dev->mem_start = 0xd0000;
c45f812f	264	pr_cont(" assigning address %#lx", dev->mem_start);
1da177e4 LT	265	} else {
	266	int high_addr_bits = inb(ioaddr+WD_CMDREG5) & 0x1f;
	267	/* Some boards don't have the register 5 -- it returns 0xff. */
	268	if (high_addr_bits == 0x1f \|\| word16 == 0)
	269	high_addr_bits = 0x01;
	270	dev->mem_start = ((reg0&0x3f) << 13) + (high_addr_bits << 19);
	271	}
	272	}
	273	#endif
	274
	275	/* The 8390 isn't at the base address -- the ASIC regs are there! */
	276	dev->base_addr = ioaddr+WD_NIC_OFFSET;
	277
	278	if (dev->irq < 2) {
b6bc7650	279	static const int irqmap[] = {9, 3, 5, 7, 10, 11, 15, 4};
1da177e4 LT	280	int reg1 = inb(ioaddr+1);
	281	int reg4 = inb(ioaddr+4);
	282	if (ancient \|\| reg1 == 0xff) { /* Ack!! No way to read the IRQ! */
	283	short nic_addr = ioaddr+WD_NIC_OFFSET;
	284	unsigned long irq_mask;
	285
	286	/* We have an old-style ethercard that doesn't report its IRQ
	287	line. Do autoirq to find the IRQ line. Note that this IS NOT
	288	a reliable way to trigger an interrupt. */
	289	outb_p(E8390_NODMA + E8390_STOP, nic_addr);
	290	outb(0x00, nic_addr+EN0_IMR); /* Disable all intrs. */
6aa20a22	291
1da177e4 LT	292	irq_mask = probe_irq_on();
	293	outb_p(0xff, nic_addr + EN0_IMR); /* Enable all interrupts. */
	294	outb_p(0x00, nic_addr + EN0_RCNTLO);
	295	outb_p(0x00, nic_addr + EN0_RCNTHI);
	296	outb(E8390_RREAD+E8390_START, nic_addr); /* Trigger it... */
	297	mdelay(20);
	298	dev->irq = probe_irq_off(irq_mask);
6aa20a22	299
1da177e4 LT	300	outb_p(0x00, nic_addr+EN0_IMR); /* Mask all intrs. again. */
1da177e4 LT	301
c45f812f MW	302	if (netif_msg_drv(ei_local))
c45f812f MW	303	pr_cont(" autoirq is %d", dev->irq);
1da177e4 LT	304	if (dev->irq < 2)
	305	dev->irq = word16 ? 10 : 5;
	306	} else
	307	dev->irq = irqmap[((reg4 >> 5) & 0x03) + (reg1 & 0x04)];
	308	} else if (dev->irq == 2) /* Fixup bogosity: IRQ2 is really IRQ9 */
	309	dev->irq = 9;
	310
	311	/* Snarf the interrupt now. There's no point in waiting since we cannot
	312	share and the board will usually be enabled. */
	313	i = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
	314	if (i) {
c45f812f	315	pr_cont(" unable to get IRQ %d.\n", dev->irq);
1da177e4 LT	316	return i;
	317	}
	318
	319	/* OK, were are certain this is going to work. Setup the device. */
	320	ei_status.name = model_name;
	321	ei_status.word16 = word16;
	322	ei_status.tx_start_page = WD_START_PG;
	323	ei_status.rx_start_page = WD_START_PG + TX_PAGES;
	324
	325	/* Don't map in the shared memory until the board is actually opened. */
	326
	327	/* Some cards (eg WD8003EBT) can be jumpered for more (32k!) memory. */
	328	if (dev->mem_end != 0) {
	329	ei_status.stop_page = (dev->mem_end - dev->mem_start)/256;
	330	ei_status.priv = dev->mem_end - dev->mem_start;
	331	} else {
	332	ei_status.stop_page = word16 ? WD13_STOP_PG : WD03_STOP_PG;
	333	dev->mem_end = dev->mem_start + (ei_status.stop_page - WD_START_PG)*256;
	334	ei_status.priv = (ei_status.stop_page - WD_START_PG)*256;
	335	}
	336
	337	ei_status.mem = ioremap(dev->mem_start, ei_status.priv);
	338	if (!ei_status.mem) {
	339	free_irq(dev->irq, dev);
	340	return -ENOMEM;
	341	}
	342
c45f812f MW	343	pr_cont(" %s, IRQ %d, shared memory at %#lx-%#lx.\n",
c45f812f MW	344	model_name, dev->irq, dev->mem_start, dev->mem_end-1);
1da177e4	345
c061b18d JP	346	ei_status.reset_8390 = wd_reset_8390;
	347	ei_status.block_input = wd_block_input;
	348	ei_status.block_output = wd_block_output;
	349	ei_status.get_8390_hdr = wd_get_8390_hdr;
458228bc SH	350
458228bc SH	351	dev->netdev_ops = &wd_netdev_ops;
d3d7b53d	352	NS8390_init(dev, 0);
c45f812f	353	ei_local->msg_enable = wd_msg_enable;
1da177e4 LT	354
	355	#if 1
	356	/* Enable interrupt generation on softconfig cards -- M.U */
	357	/* .. but possibly potentially unsafe - Donald */
	358	if (inb(ioaddr+14) & 0x20)
	359	outb(inb(ioaddr+4)\|0x80, ioaddr+4);
	360	#endif
	361
b1fc5505	362	err = register_netdev(dev);
bdb0f867	363	if (err) {
b1fc5505	364	free_irq(dev->irq, dev);
bdb0f867 KV	365	iounmap(ei_status.mem);
bdb0f867 KV	366	}
b1fc5505	367	return err;
1da177e4 LT	368	}
	369
	370	static int
	371	wd_open(struct net_device *dev)
	372	{
	373	int ioaddr = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
	374
	375	/* Map in the shared memory. Always set register 0 last to remain
	376	compatible with very old boards. */
	377	ei_status.reg0 = ((dev->mem_start>>13) & 0x3f) \| WD_MEMENB;
	378	ei_status.reg5 = ((dev->mem_start>>19) & 0x1f) \| NIC16;
	379
	380	if (ei_status.word16)
	381	outb(ei_status.reg5, ioaddr+WD_CMDREG5);
	382	outb(ei_status.reg0, ioaddr); /* WD_CMDREG */
	383
458228bc	384	return ei_open(dev);
1da177e4 LT	385	}
	386
	387	static void
	388	wd_reset_8390(struct net_device *dev)
	389	{
	390	int wd_cmd_port = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
c45f812f	391	struct ei_device *ei_local = netdev_priv(dev);
1da177e4 LT	392
1da177e4 LT	393	outb(WD_RESET, wd_cmd_port);
c45f812f MW	394	netif_dbg(ei_local, hw, dev, "resetting the WD80x3 t=%lu...\n",
c45f812f MW	395	jiffies);
1da177e4 LT	396	ei_status.txing = 0;
	397
	398	/* Set up the ASIC registers, just in case something changed them. */
	399	outb((((dev->mem_start>>13) & 0x3f)\|WD_MEMENB), wd_cmd_port);
	400	if (ei_status.word16)
	401	outb(NIC16 \| ((dev->mem_start>>19) & 0x1f), wd_cmd_port+WD_CMDREG5);
	402
c45f812f	403	netif_dbg(ei_local, hw, dev, "reset done\n");
1da177e4 LT	404	}
	405
	406	/* Grab the 8390 specific header. Similar to the block_input routine, but
	407	we don't need to be concerned with ring wrap as the header will be at
	408	the start of a page, so we optimize accordingly. */
	409
	410	static void
	411	wd_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr, int ring_page)
	412	{
	413
	414	int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
	415	void __iomem *hdr_start = ei_status.mem + ((ring_page - WD_START_PG)<<8);
	416
	417	/* We'll always get a 4 byte header read followed by a packet read, so
	418	we enable 16 bit mode before the header, and disable after the body. */
	419	if (ei_status.word16)
	420	outb(ISA16 \| ei_status.reg5, wd_cmdreg+WD_CMDREG5);
	421
	422	#ifdef __BIG_ENDIAN
	423	/* Officially this is what we are doing, but the readl() is faster */
	424	/* unfortunately it isn't endian aware of the struct */
	425	memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
	426	hdr->count = le16_to_cpu(hdr->count);
	427	#else
	428	((unsigned int*)hdr)[0] = readl(hdr_start);
	429	#endif
	430	}
	431
	432	/* Block input and output are easy on shared memory ethercards, and trivial
	433	on the Western digital card where there is no choice of how to do it.
	434	The only complications are that the ring buffer wraps, and need to map
	435	switch between 8- and 16-bit modes. */
	436
	437	static void
	438	wd_block_input(struct net_device dev, int count, struct sk_buff skb, int ring_offset)
	439	{
	440	int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
	441	unsigned long offset = ring_offset - (WD_START_PG<<8);
	442	void __iomem *xfer_start = ei_status.mem + offset;
	443
	444	if (offset + count > ei_status.priv) {
	445	/* We must wrap the input move. */
	446	int semi_count = ei_status.priv - offset;
	447	memcpy_fromio(skb->data, xfer_start, semi_count);
	448	count -= semi_count;
	449	memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
	450	} else {
	451	/* Packet is in one chunk -- we can copy + cksum. */
4ec03116	452	memcpy_fromio(skb->data, xfer_start, count);
1da177e4 LT	453	}
	454
	455	/* Turn off 16 bit access so that reboot works. ISA brain-damage */
	456	if (ei_status.word16)
	457	outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
	458	}
	459
	460	static void
	461	wd_block_output(struct net_device dev, int count, const unsigned char buf,
	462	int start_page)
	463	{
	464	int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
	465	void __iomem *shmem = ei_status.mem + ((start_page - WD_START_PG)<<8);
	466
	467
	468	if (ei_status.word16) {
	469	/* Turn on and off 16 bit access so that reboot works. */
	470	outb(ISA16 \| ei_status.reg5, wd_cmdreg+WD_CMDREG5);
	471	memcpy_toio(shmem, buf, count);
	472	outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
	473	} else
	474	memcpy_toio(shmem, buf, count);
	475	}
	476
	477
	478	static int
	479	wd_close(struct net_device *dev)
	480	{
	481	int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
c45f812f	482	struct ei_device *ei_local = netdev_priv(dev);
1da177e4	483
c45f812f	484	netif_dbg(ei_local, ifdown, dev, "Shutting down ethercard.\n");
1da177e4 LT	485	ei_close(dev);
	486
	487	/* Change from 16-bit to 8-bit shared memory so reboot works. */
	488	if (ei_status.word16)
	489	outb(ei_status.reg5, wd_cmdreg + WD_CMDREG5 );
	490
	491	/* And disable the shared memory. */
	492	outb(ei_status.reg0 & ~WD_MEMENB, wd_cmdreg);
	493
	494	return 0;
	495	}
	496
6aa20a22	497
1da177e4 LT	498	#ifdef MODULE
	499	#define MAX_WD_CARDS 4 /* Max number of wd cards per module */
	500	static struct net_device *dev_wd[MAX_WD_CARDS];
	501	static int io[MAX_WD_CARDS];
	502	static int irq[MAX_WD_CARDS];
	503	static int mem[MAX_WD_CARDS];
	504	static int mem_end[MAX_WD_CARDS]; /* for non std. mem size */
	505
df298408 DH	506	module_param_hw_array(io, int, ioport, NULL, 0);
	507	module_param_hw_array(irq, int, irq, NULL, 0);
	508	module_param_hw_array(mem, int, iomem, NULL, 0);
	509	module_param_hw_array(mem_end, int, iomem, NULL, 0);
c45f812f	510	module_param_named(msg_enable, wd_msg_enable, uint, (S_IRUSR\|S_IRGRP\|S_IROTH));
1da177e4 LT	511	MODULE_PARM_DESC(io, "I/O base address(es)");
	512	MODULE_PARM_DESC(irq, "IRQ number(s) (ignored for PureData boards)");
	513	MODULE_PARM_DESC(mem, "memory base address(es)(ignored for PureData boards)");
	514	MODULE_PARM_DESC(mem_end, "memory end address(es)");
c45f812f	515	MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)");
1da177e4 LT	516	MODULE_DESCRIPTION("ISA Western Digital wd8003/wd8013 ; SMC Elite, Elite16 ethernet driver");
	517	MODULE_LICENSE("GPL");
	518
	519	/* This is set up so that only a single autoprobe takes place per call.
	520	ISA device autoprobes on a running machine are not recommended. */
5e5fa01d AM	521
5e5fa01d AM	522	int __init init_module(void)
1da177e4 LT	523	{
	524	struct net_device *dev;
	525	int this_dev, found = 0;
	526
	527	for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
	528	if (io[this_dev] == 0) {
	529	if (this_dev != 0) break; /* only autoprobe 1st one */
	530	printk(KERN_NOTICE "wd.c: Presently autoprobing (not recommended) for a single card.\n");
	531	}
	532	dev = alloc_ei_netdev();
	533	if (!dev)
	534	break;
	535	dev->irq = irq[this_dev];
	536	dev->base_addr = io[this_dev];
	537	dev->mem_start = mem[this_dev];
	538	dev->mem_end = mem_end[this_dev];
	539	if (do_wd_probe(dev) == 0) {
b1fc5505 HX	540	dev_wd[found++] = dev;
b1fc5505 HX	541	continue;
1da177e4 LT	542	}
	543	free_netdev(dev);
	544	printk(KERN_WARNING "wd.c: No wd80x3 card found (i/o = 0x%x).\n", io[this_dev]);
	545	break;
	546	}
	547	if (found)
	548	return 0;
	549	return -ENXIO;
	550	}
	551
64916f1e DV	552	static void cleanup_card(struct net_device *dev)
	553	{
	554	free_irq(dev->irq, dev);
	555	release_region(dev->base_addr - WD_NIC_OFFSET, WD_IO_EXTENT);
	556	iounmap(ei_status.mem);
	557	}
	558
afc8eb46	559	void __exit
1da177e4 LT	560	cleanup_module(void)
	561	{
	562	int this_dev;
	563
	564	for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
	565	struct net_device *dev = dev_wd[this_dev];
	566	if (dev) {
	567	unregister_netdev(dev);
	568	cleanup_card(dev);
	569	free_netdev(dev);
	570	}
	571	}
	572	}
	573	#endif /* MODULE */