Commit 15d07f9e authored by Andrew Lunn's avatar Andrew Lunn Committed by Jakub Kicinski
Browse files

drivers: net: 8390: wd80x3: Remove this driver 



The wd80x3 was written by Donald Becker 1993 to 1994. It is an ISA
device, so unlikely to be used with modern kernels.

Acked-by: default avatarDominik Brodowski <linux@dominikbrodowski.net>
Signed-off-by: default avatarAndrew Lunn <andrew@lunn.ch>
Link: https://patch.msgid.link/20260422-v7-0-0-net-next-driver-removal-v1-v2-15-08a5b59784d5@lunn.ch


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent b0b807aa

MAINTAINERS

+1 −1
Original line number Diff line number Diff line
@@ -137,7 +137,7 @@ T: git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty.git 
F:	drivers/tty/serial/8250*

F:	include/linux/serial_8250.h









8390 NETWORK DRIVERS [WD80x3/SMC-ELITE, SMC-ULTRA, NE2000, 3C503, etc.]









8390 NETWORK DRIVERS [NE2000, 3C503, etc.]









L:	netdev@vger.kernel.org









S:	Orphan / Obsolete









F:	drivers/net/ethernet/8390/
































drivers/net/Space.c



+0
−3






























Original line number
Diff line number
Diff line







@@ -200,9 +200,6 @@ static int __init probe_list2(int unit, struct devprobe2 *p, int autoprobe)







 * look for EISA/PCI cards in addition to ISA cards).









 */









static struct devprobe2 isa_probes[] __initdata = {









#ifdef CONFIG_WD80x3









	{wd_probe, 0},









#endif









#if defined(CONFIG_NE2000) /* ISA (use ne2k-pci for PCI cards) */









	{ne_probe, 0},









#endif
































drivers/net/ethernet/8390/Kconfig



+0
−11






























Original line number
Diff line number
Diff line







@@ -155,17 +155,6 @@ config STNIC

















	  If unsure, say N.



















config WD80x3









	tristate "WD80*3 support"









	depends on ISA









	select NETDEV_LEGACY_INIT









	select CRC32









	help









	  If you have a network (Ethernet) card of this type, say Y here.



















	  To compile this driver as a module, choose M here. The module









	  will be called wd.



















config ZORRO8390









	tristate "Zorro NS8390-based Ethernet support"









	depends on ZORRO
































drivers/net/ethernet/8390/Makefile



+0
−1






























Original line number
Diff line number
Diff line







@@ -13,6 +13,5 @@ obj-$(CONFIG_NE2000) += ne.o 8390p.o







obj-$(CONFIG_NE2K_PCI) += ne2k-pci.o 8390.o









obj-$(CONFIG_PCMCIA_PCNET) += pcnet_cs.o 8390.o









obj-$(CONFIG_STNIC) += stnic.o 8390.o









obj-$(CONFIG_WD80x3) += wd.o 8390.o









obj-$(CONFIG_XSURF100) += xsurf100.o









obj-$(CONFIG_ZORRO8390) += zorro8390.o
























drivers/net/ethernet/8390/wd.c
deleted100644 → 0



+0
−575






























Original line number
Diff line number
Diff line









// SPDX-License-Identifier: GPL-1.0+









/* 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.



















	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 <net/Space.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 */









	u8 addr[ETH_ALEN];









	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++)









		addr[i] = inb(ioaddr + 8 + i);









	eth_hw_addr_set(dev, addr);



















	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 (wd_msg_enable & NETIF_MSG_PROBE)









				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, 0444);









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. */



















static int __init wd_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;









}









module_init(wd_init_module);



















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);









}



















static void __exit wd_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);









		}









	}









}









module_exit(wd_cleanup_module);









#endif /* MODULE */