[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,
	.ndo_change_mtu		= eth_change_mtu,
#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_array(io, int, NULL, 0);
module_param_array(irq, int, NULL, 0);
module_param_array(mem, int, NULL, 0);
module_param_array(mem_end, int, 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	.ndo_change_mtu = eth_change_mtu,
	160	#ifdef CONFIG_NET_POLL_CONTROLLER
	161	.ndo_poll_controller = ei_poll,
	162	#endif
	163	};
	164
1da177e4 LT	165	static int __init wd_probe1(struct net_device *dev, int ioaddr)
	166	{
	167	int i;
b1fc5505	168	int err;
1da177e4 LT	169	int checksum = 0;
	170	int ancient = 0; /* An old card without config registers. */
	171	int word16 = 0; /* 0 = 8 bit, 1 = 16 bit */
	172	const char *model_name;
	173	static unsigned version_printed;
c45f812f	174	struct ei_device *ei_local = netdev_priv(dev);
1da177e4 LT	175
	176	for (i = 0; i < 8; i++)
	177	checksum += inb(ioaddr + 8 + i);
	178	if (inb(ioaddr + 8) == 0xff /* Extra check to avoid soundcard. */
	179	\|\| inb(ioaddr + 9) == 0xff
	180	\|\| (checksum & 0xff) != 0xFF)
	181	return -ENODEV;
	182
	183	/* Check for semi-valid mem_start/end values if supplied. */
	184	if ((dev->mem_start % 0x2000) \|\| (dev->mem_end % 0x2000)) {
c45f812f MW	185	netdev_warn(dev,
c45f812f MW	186	"wd.c: user supplied mem_start or mem_end not on 8kB boundary - ignored.\n");
1da177e4 LT	187	dev->mem_start = 0;
	188	dev->mem_end = 0;
	189	}
	190
c45f812f MW	191	if ((wd_msg_enable & NETIF_MSG_DRV) && (version_printed++ == 0))
c45f812f MW	192	netdev_info(dev, version);
1da177e4	193
1da177e4	194	for (i = 0; i < 6; i++)
0795af57 JP	195	dev->dev_addr[i] = inb(ioaddr + 8 + i);
0795af57 JP	196
c45f812f	197	netdev_info(dev, "WD80x3 at %#3x, %pM", ioaddr, dev->dev_addr);
1da177e4 LT	198
	199	/* The following PureData probe code was contributed by
	200	Mike Jagdis <jaggy@purplet.demon.co.uk>. Puredata does software
	201	configuration differently from others so we have to check for them.
	202	This detects an 8 bit, 16 bit or dumb (Toshiba, jumpered) card.
	203	*/
	204	if (inb(ioaddr+0) == 'P' && inb(ioaddr+1) == 'D') {
	205	unsigned char reg5 = inb(ioaddr+5);
	206
	207	switch (inb(ioaddr+2)) {
	208	case 0x03: word16 = 0; model_name = "PDI8023-8"; break;
	209	case 0x05: word16 = 0; model_name = "PDUC8023"; break;
	210	case 0x0a: word16 = 1; model_name = "PDI8023-16"; break;
	211	/* Either 0x01 (dumb) or they've released a new version. */
	212	default: word16 = 0; model_name = "PDI8023"; break;
	213	}
	214	dev->mem_start = ((reg5 & 0x1c) + 0xc0) << 12;
	215	dev->irq = (reg5 & 0xe0) == 0xe0 ? 10 : (reg5 >> 5) + 1;
	216	} else { /* End of PureData probe */
	217	/* This method of checking for a 16-bit board is borrowed from the
	218	we.c driver. A simpler method is just to look in ASIC reg. 0x03.
	219	I'm comparing the two method in alpha test to make certain they
	220	return the same result. */
	221	/* Check for the old 8 bit board - it has register 0/8 aliasing.
	222	Do NOT check i>=6 here -- it hangs the old 8003 boards! */
	223	for (i = 0; i < 6; i++)
	224	if (inb(ioaddr+i) != inb(ioaddr+8+i))
	225	break;
	226	if (i >= 6) {
	227	ancient = 1;
	228	model_name = "WD8003-old";
	229	word16 = 0;
	230	} else {
	231	int tmp = inb(ioaddr+1); /* fiddle with 16bit bit */
	232	outb( tmp ^ 0x01, ioaddr+1 ); /* attempt to clear 16bit bit */
	233	if (((inb( ioaddr+1) & 0x01) == 0x01) /* A 16 bit card */
	234	&& (tmp & 0x01) == 0x01 ) { /* In a 16 slot. */
	235	int asic_reg5 = inb(ioaddr+WD_CMDREG5);
	236	/* Magic to set ASIC to word-wide mode. */
	237	outb( NIC16 \| (asic_reg5&0x1f), ioaddr+WD_CMDREG5);
	238	outb(tmp, ioaddr+1);
	239	model_name = "WD8013";
	240	word16 = 1; /* We have a 16bit board here! */
	241	} else {
	242	model_name = "WD8003";
	243	word16 = 0;
	244	}
	245	outb(tmp, ioaddr+1); /* Restore original reg1 value. */
	246	}
	247	#ifndef final_version
	248	if ( !ancient && (inb(ioaddr+1) & 0x01) != (word16 & 0x01))
c45f812f MW	249	pr_cont("\nWD80?3: Bus width conflict, %d (probe) != %d (reg report).",
	250	word16 ? 16 : 8,
	251	(inb(ioaddr+1) & 0x01) ? 16 : 8);
1da177e4 LT	252	#endif
	253	}
	254
	255	#if defined(WD_SHMEM) && WD_SHMEM > 0x80000
	256	/* Allow a compile-time override. */
	257	dev->mem_start = WD_SHMEM;
	258	#else
	259	if (dev->mem_start == 0) {
	260	/* Sanity and old 8003 check */
	261	int reg0 = inb(ioaddr);
	262	if (reg0 == 0xff \|\| reg0 == 0) {
	263	/* Future plan: this could check a few likely locations first. */
	264	dev->mem_start = 0xd0000;
c45f812f	265	pr_cont(" assigning address %#lx", dev->mem_start);
1da177e4 LT	266	} else {
	267	int high_addr_bits = inb(ioaddr+WD_CMDREG5) & 0x1f;
	268	/* Some boards don't have the register 5 -- it returns 0xff. */
	269	if (high_addr_bits == 0x1f \|\| word16 == 0)
	270	high_addr_bits = 0x01;
	271	dev->mem_start = ((reg0&0x3f) << 13) + (high_addr_bits << 19);
	272	}
	273	}
	274	#endif
	275
	276	/* The 8390 isn't at the base address -- the ASIC regs are there! */
	277	dev->base_addr = ioaddr+WD_NIC_OFFSET;
	278
	279	if (dev->irq < 2) {
b6bc7650	280	static const int irqmap[] = {9, 3, 5, 7, 10, 11, 15, 4};
1da177e4 LT	281	int reg1 = inb(ioaddr+1);
	282	int reg4 = inb(ioaddr+4);
	283	if (ancient \|\| reg1 == 0xff) { /* Ack!! No way to read the IRQ! */
	284	short nic_addr = ioaddr+WD_NIC_OFFSET;
	285	unsigned long irq_mask;
	286
	287	/* We have an old-style ethercard that doesn't report its IRQ
	288	line. Do autoirq to find the IRQ line. Note that this IS NOT
	289	a reliable way to trigger an interrupt. */
	290	outb_p(E8390_NODMA + E8390_STOP, nic_addr);
	291	outb(0x00, nic_addr+EN0_IMR); /* Disable all intrs. */
6aa20a22	292
1da177e4 LT	293	irq_mask = probe_irq_on();
	294	outb_p(0xff, nic_addr + EN0_IMR); /* Enable all interrupts. */
	295	outb_p(0x00, nic_addr + EN0_RCNTLO);
	296	outb_p(0x00, nic_addr + EN0_RCNTHI);
	297	outb(E8390_RREAD+E8390_START, nic_addr); /* Trigger it... */
	298	mdelay(20);
	299	dev->irq = probe_irq_off(irq_mask);
6aa20a22	300
1da177e4 LT	301	outb_p(0x00, nic_addr+EN0_IMR); /* Mask all intrs. again. */
1da177e4 LT	302
c45f812f MW	303	if (netif_msg_drv(ei_local))
c45f812f MW	304	pr_cont(" autoirq is %d", dev->irq);
1da177e4 LT	305	if (dev->irq < 2)
	306	dev->irq = word16 ? 10 : 5;
	307	} else
	308	dev->irq = irqmap[((reg4 >> 5) & 0x03) + (reg1 & 0x04)];
	309	} else if (dev->irq == 2) /* Fixup bogosity: IRQ2 is really IRQ9 */
	310	dev->irq = 9;
	311
	312	/* Snarf the interrupt now. There's no point in waiting since we cannot
	313	share and the board will usually be enabled. */
	314	i = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
	315	if (i) {
c45f812f	316	pr_cont(" unable to get IRQ %d.\n", dev->irq);
1da177e4 LT	317	return i;
	318	}
	319
	320	/* OK, were are certain this is going to work. Setup the device. */
	321	ei_status.name = model_name;
	322	ei_status.word16 = word16;
	323	ei_status.tx_start_page = WD_START_PG;
	324	ei_status.rx_start_page = WD_START_PG + TX_PAGES;
	325
	326	/* Don't map in the shared memory until the board is actually opened. */
	327
	328	/* Some cards (eg WD8003EBT) can be jumpered for more (32k!) memory. */
	329	if (dev->mem_end != 0) {
	330	ei_status.stop_page = (dev->mem_end - dev->mem_start)/256;
	331	ei_status.priv = dev->mem_end - dev->mem_start;
	332	} else {
	333	ei_status.stop_page = word16 ? WD13_STOP_PG : WD03_STOP_PG;
	334	dev->mem_end = dev->mem_start + (ei_status.stop_page - WD_START_PG)*256;
	335	ei_status.priv = (ei_status.stop_page - WD_START_PG)*256;
	336	}
	337
	338	ei_status.mem = ioremap(dev->mem_start, ei_status.priv);
	339	if (!ei_status.mem) {
	340	free_irq(dev->irq, dev);
	341	return -ENOMEM;
	342	}
	343
c45f812f MW	344	pr_cont(" %s, IRQ %d, shared memory at %#lx-%#lx.\n",
c45f812f MW	345	model_name, dev->irq, dev->mem_start, dev->mem_end-1);
1da177e4	346
c061b18d JP	347	ei_status.reset_8390 = wd_reset_8390;
	348	ei_status.block_input = wd_block_input;
	349	ei_status.block_output = wd_block_output;
	350	ei_status.get_8390_hdr = wd_get_8390_hdr;
458228bc SH	351
458228bc SH	352	dev->netdev_ops = &wd_netdev_ops;
d3d7b53d	353	NS8390_init(dev, 0);
c45f812f	354	ei_local->msg_enable = wd_msg_enable;
1da177e4 LT	355
	356	#if 1
	357	/* Enable interrupt generation on softconfig cards -- M.U */
	358	/* .. but possibly potentially unsafe - Donald */
	359	if (inb(ioaddr+14) & 0x20)
	360	outb(inb(ioaddr+4)\|0x80, ioaddr+4);
	361	#endif
	362
b1fc5505	363	err = register_netdev(dev);
bdb0f867	364	if (err) {
b1fc5505	365	free_irq(dev->irq, dev);
bdb0f867 KV	366	iounmap(ei_status.mem);
bdb0f867 KV	367	}
b1fc5505	368	return err;
1da177e4 LT	369	}
	370
	371	static int
	372	wd_open(struct net_device *dev)
	373	{
	374	int ioaddr = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
	375
	376	/* Map in the shared memory. Always set register 0 last to remain
	377	compatible with very old boards. */
	378	ei_status.reg0 = ((dev->mem_start>>13) & 0x3f) \| WD_MEMENB;
	379	ei_status.reg5 = ((dev->mem_start>>19) & 0x1f) \| NIC16;
	380
	381	if (ei_status.word16)
	382	outb(ei_status.reg5, ioaddr+WD_CMDREG5);
	383	outb(ei_status.reg0, ioaddr); /* WD_CMDREG */
	384
458228bc	385	return ei_open(dev);
1da177e4 LT	386	}
	387
	388	static void
	389	wd_reset_8390(struct net_device *dev)
	390	{
	391	int wd_cmd_port = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
c45f812f	392	struct ei_device *ei_local = netdev_priv(dev);
1da177e4 LT	393
1da177e4 LT	394	outb(WD_RESET, wd_cmd_port);
c45f812f MW	395	netif_dbg(ei_local, hw, dev, "resetting the WD80x3 t=%lu...\n",
c45f812f MW	396	jiffies);
1da177e4 LT	397	ei_status.txing = 0;
	398
	399	/* Set up the ASIC registers, just in case something changed them. */
	400	outb((((dev->mem_start>>13) & 0x3f)\|WD_MEMENB), wd_cmd_port);
	401	if (ei_status.word16)
	402	outb(NIC16 \| ((dev->mem_start>>19) & 0x1f), wd_cmd_port+WD_CMDREG5);
	403
c45f812f	404	netif_dbg(ei_local, hw, dev, "reset done\n");
1da177e4 LT	405	}
	406
	407	/* Grab the 8390 specific header. Similar to the block_input routine, but
	408	we don't need to be concerned with ring wrap as the header will be at
	409	the start of a page, so we optimize accordingly. */
	410
	411	static void
	412	wd_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr, int ring_page)
	413	{
	414
	415	int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
	416	void __iomem *hdr_start = ei_status.mem + ((ring_page - WD_START_PG)<<8);
	417
	418	/* We'll always get a 4 byte header read followed by a packet read, so
	419	we enable 16 bit mode before the header, and disable after the body. */
	420	if (ei_status.word16)
	421	outb(ISA16 \| ei_status.reg5, wd_cmdreg+WD_CMDREG5);
	422
	423	#ifdef __BIG_ENDIAN
	424	/* Officially this is what we are doing, but the readl() is faster */
	425	/* unfortunately it isn't endian aware of the struct */
	426	memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
	427	hdr->count = le16_to_cpu(hdr->count);
	428	#else
	429	((unsigned int*)hdr)[0] = readl(hdr_start);
	430	#endif
	431	}
	432
	433	/* Block input and output are easy on shared memory ethercards, and trivial
	434	on the Western digital card where there is no choice of how to do it.
	435	The only complications are that the ring buffer wraps, and need to map
	436	switch between 8- and 16-bit modes. */
	437
	438	static void
	439	wd_block_input(struct net_device dev, int count, struct sk_buff skb, int ring_offset)
	440	{
	441	int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
	442	unsigned long offset = ring_offset - (WD_START_PG<<8);
	443	void __iomem *xfer_start = ei_status.mem + offset;
	444
	445	if (offset + count > ei_status.priv) {
	446	/* We must wrap the input move. */
	447	int semi_count = ei_status.priv - offset;
	448	memcpy_fromio(skb->data, xfer_start, semi_count);
	449	count -= semi_count;
	450	memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
	451	} else {
	452	/* Packet is in one chunk -- we can copy + cksum. */
4ec03116	453	memcpy_fromio(skb->data, xfer_start, count);
1da177e4 LT	454	}
	455
	456	/* Turn off 16 bit access so that reboot works. ISA brain-damage */
	457	if (ei_status.word16)
	458	outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
	459	}
	460
	461	static void
	462	wd_block_output(struct net_device dev, int count, const unsigned char buf,
	463	int start_page)
	464	{
	465	int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
	466	void __iomem *shmem = ei_status.mem + ((start_page - WD_START_PG)<<8);
	467
	468
	469	if (ei_status.word16) {
	470	/* Turn on and off 16 bit access so that reboot works. */
	471	outb(ISA16 \| ei_status.reg5, wd_cmdreg+WD_CMDREG5);
	472	memcpy_toio(shmem, buf, count);
	473	outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
	474	} else
	475	memcpy_toio(shmem, buf, count);
	476	}
	477
	478
	479	static int
	480	wd_close(struct net_device *dev)
	481	{
	482	int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
c45f812f	483	struct ei_device *ei_local = netdev_priv(dev);
1da177e4	484
c45f812f	485	netif_dbg(ei_local, ifdown, dev, "Shutting down ethercard.\n");
1da177e4 LT	486	ei_close(dev);
	487
	488	/* Change from 16-bit to 8-bit shared memory so reboot works. */
	489	if (ei_status.word16)
	490	outb(ei_status.reg5, wd_cmdreg + WD_CMDREG5 );
	491
	492	/* And disable the shared memory. */
	493	outb(ei_status.reg0 & ~WD_MEMENB, wd_cmdreg);
	494
	495	return 0;
	496	}
	497
6aa20a22	498
1da177e4 LT	499	#ifdef MODULE
	500	#define MAX_WD_CARDS 4 /* Max number of wd cards per module */
	501	static struct net_device *dev_wd[MAX_WD_CARDS];
	502	static int io[MAX_WD_CARDS];
	503	static int irq[MAX_WD_CARDS];
	504	static int mem[MAX_WD_CARDS];
	505	static int mem_end[MAX_WD_CARDS]; /* for non std. mem size */
	506
	507	module_param_array(io, int, NULL, 0);
	508	module_param_array(irq, int, NULL, 0);
	509	module_param_array(mem, int, NULL, 0);
	510	module_param_array(mem_end, int, NULL, 0);
c45f812f	511	module_param_named(msg_enable, wd_msg_enable, uint, (S_IRUSR\|S_IRGRP\|S_IROTH));
1da177e4 LT	512	MODULE_PARM_DESC(io, "I/O base address(es)");
	513	MODULE_PARM_DESC(irq, "IRQ number(s) (ignored for PureData boards)");
	514	MODULE_PARM_DESC(mem, "memory base address(es)(ignored for PureData boards)");
	515	MODULE_PARM_DESC(mem_end, "memory end address(es)");
c45f812f	516	MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)");
1da177e4 LT	517	MODULE_DESCRIPTION("ISA Western Digital wd8003/wd8013 ; SMC Elite, Elite16 ethernet driver");
	518	MODULE_LICENSE("GPL");
	519
	520	/* This is set up so that only a single autoprobe takes place per call.
	521	ISA device autoprobes on a running machine are not recommended. */
5e5fa01d AM	522
5e5fa01d AM	523	int __init init_module(void)
1da177e4 LT	524	{
	525	struct net_device *dev;
	526	int this_dev, found = 0;
	527
	528	for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
	529	if (io[this_dev] == 0) {
	530	if (this_dev != 0) break; /* only autoprobe 1st one */
	531	printk(KERN_NOTICE "wd.c: Presently autoprobing (not recommended) for a single card.\n");
	532	}
	533	dev = alloc_ei_netdev();
	534	if (!dev)
	535	break;
	536	dev->irq = irq[this_dev];
	537	dev->base_addr = io[this_dev];
	538	dev->mem_start = mem[this_dev];
	539	dev->mem_end = mem_end[this_dev];
	540	if (do_wd_probe(dev) == 0) {
b1fc5505 HX	541	dev_wd[found++] = dev;
b1fc5505 HX	542	continue;
1da177e4 LT	543	}
	544	free_netdev(dev);
	545	printk(KERN_WARNING "wd.c: No wd80x3 card found (i/o = 0x%x).\n", io[this_dev]);
	546	break;
	547	}
	548	if (found)
	549	return 0;
	550	return -ENXIO;
	551	}
	552
64916f1e DV	553	static void cleanup_card(struct net_device *dev)
	554	{
	555	free_irq(dev->irq, dev);
	556	release_region(dev->base_addr - WD_NIC_OFFSET, WD_IO_EXTENT);
	557	iounmap(ei_status.mem);
	558	}
	559
afc8eb46	560	void __exit
1da177e4 LT	561	cleanup_module(void)
	562	{
	563	int this_dev;
	564
	565	for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
	566	struct net_device *dev = dev_wd[this_dev];
	567	if (dev) {
	568	unregister_netdev(dev);
	569	cleanup_card(dev);
	570	free_netdev(dev);
	571	}
	572	}
	573	}
	574	#endif /* MODULE */