err = do_el2_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
     dev->poll_controller = ei_poll;
 #endif
 
+    retval = register_netdev(dev);
+    if (retval)
+       goto out1;
+
     if (dev->mem_start)
        printk("%s: %s - %dkB RAM, 8kB shared mem window at %#6lx-%#6lx.\n",
                dev->name, ei_status.name, (wordlength+1)<<3,
                dev->base_addr = io[this_dev];
                dev->mem_end = xcvr[this_dev];  /* low 4bits = xcvr sel. */
                if (do_el2_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_el2[found++] = dev;
-                               continue;
-                       }
-                       cleanup_card(dev);
+                       dev_el2[found++] = dev;
+                       continue;
                }
                free_netdev(dev);
                printk(KERN_WARNING "3c503.c: No 3c503 card found (i/o = 0x%x).\n", io[this_dev]);
 
 #endif /* __ISAPNP__ */
 
 static struct net_device *corkscrew_scan(int unit);
-static void corkscrew_setup(struct net_device *dev, int ioaddr,
+static int corkscrew_setup(struct net_device *dev, int ioaddr,
                            struct pnp_dev *idev, int card_number);
 static int corkscrew_open(struct net_device *dev);
 static void corkscrew_timer(unsigned long arg);
                        printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
                                inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
                        /* irq = inw(ioaddr + 0x2002) & 15; */ /* Use the irq from isapnp */
-                       corkscrew_setup(dev, ioaddr, idev, cards_found++);
                        SET_NETDEV_DEV(dev, &idev->dev);
                        pnp_cards++;
-                       err = register_netdev(dev);
+                       err = corkscrew_setup(dev, ioaddr, idev, cards_found++);
                        if (!err)
                                return dev;
                        cleanup_card(dev);
 
                printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
                     inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
-               corkscrew_setup(dev, ioaddr, NULL, cards_found++);
-               err = register_netdev(dev);
+               err = corkscrew_setup(dev, ioaddr, NULL, cards_found++);
                if (!err)
                        return dev;
                cleanup_card(dev);
        return NULL;
 }
 
-static void corkscrew_setup(struct net_device *dev, int ioaddr,
+static int corkscrew_setup(struct net_device *dev, int ioaddr,
                            struct pnp_dev *idev, int card_number)
 {
        struct corkscrew_private *vp = netdev_priv(dev);
        dev->get_stats = &corkscrew_get_stats;
        dev->set_multicast_list = &set_rx_mode;
        dev->ethtool_ops = &netdev_ethtool_ops;
+
+       return register_netdev(dev);
 }
 \f
 
 
         dev->flags&=~IFF_MULTICAST;     /* Multicast doesn't work */
 #endif
 
+       retval = register_netdev(dev);
+       if (retval)
+               goto err_out;
+
        return 0;
 err_out:
        mca_set_adapter_procfn(slot, NULL, NULL);
        err = do_elmc_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
                dev->irq=irq[this_dev];
                dev->base_addr=io[this_dev];
                if (do_elmc_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_elmc[this_dev] = dev;
-                               found++;
-                               continue;
-                       }
-                       cleanup_card(dev);
+                       dev_elmc[this_dev] = dev;
+                       found++;
+                       continue;
                }
                free_netdev(dev);
                if (io[this_dev]==0)
 
        err = do_ac3200_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
        dev->poll_controller = ei_poll;
 #endif
        NS8390_init(dev, 0);
+
+       retval = register_netdev(dev);
+       if (retval)
+               goto out2;
        return 0;
+out2:
+       if (ei_status.reg0)
+               iounmap((void *)dev->mem_start);
 out1:
        free_irq(dev->irq, dev);
 out:
                dev->base_addr = io[this_dev];
                dev->mem_start = mem[this_dev];         /* Currently ignored by driver */
                if (do_ac3200_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_ac32[found++] = dev;
-                               continue;
-                       }
-                       cleanup_card(dev);
+                       dev_ac32[found++] = dev;
+                       continue;
                }
                free_netdev(dev);
                printk(KERN_WARNING "ac3200.c: No ac3200 card found (i/o = 0x%x).\n", io[this_dev]);
 
        }
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       outw(PP_ChipID, dev->base_addr + ADD_PORT);
-       release_region(dev->base_addr, NETCARD_IO_EXTENT);
 out:
        free_netdev(dev);
        printk(KERN_WARNING "cs89x0: no cs8900 or cs8920 detected.  Be sure to disable PnP with SETUP\n");
        printk("\n");
        if (net_debug)
                printk("cs89x0_probe1() successful\n");
+
+       retval = register_netdev(dev);
+       if (retval)
+               goto out3;
        return 0;
+out3:
+       outw(PP_ChipID, dev->base_addr + ADD_PORT);
 out2:
        release_region(ioaddr & ~3, NETCARD_IO_EXTENT);
 out1:
        if (ret)
                goto out;
 
-        if (register_netdev(dev) != 0) {
-                printk(KERN_ERR "cs89x0.c: No card found at 0x%x\n", io);
-                ret = -ENXIO;
-               outw(PP_ChipID, dev->base_addr + ADD_PORT);
-               release_region(dev->base_addr, NETCARD_IO_EXTENT);
-               goto out;
-        }
        dev_cs89x0 = dev;
        return 0;
 out:
 
        err = do_e2100_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
 #endif
        NS8390_init(dev, 0);
 
+       retval = register_netdev(dev);
+       if (retval)
+               goto out;
        return 0;
 out:
        release_region(ioaddr, E21_IO_EXTENT);
                dev->mem_start = mem[this_dev];
                dev->mem_end = xcvr[this_dev];  /* low 4bits = xcvr sel. */
                if (do_e2100_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_e21[found++] = dev;
-                               continue;
-                       }
-                       cleanup_card(dev);
+                       dev_e21[found++] = dev;
+                       continue;
                }
                free_netdev(dev);
                printk(KERN_WARNING "e2100.c: No E2100 card found (i/o = 0x%x).\n", io[this_dev]);
 
        err = do_eepro_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       release_region(dev->base_addr, EEPRO_IO_EXTENT);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
        int i;
        struct eepro_local *lp;
        int ioaddr = dev->base_addr;
+       int err;
 
        /* Grab the region so we can find another board if autoIRQ fails. */
        if (!request_region(ioaddr, EEPRO_IO_EXTENT, DRV_NAME)) { 
 
        /* reset 82595 */
        eepro_reset(ioaddr);
+
+       err = register_netdev(dev);
+       if (err)
+               goto err;
        return 0;
 exit:
+       err = -ENODEV;
+err:
        release_region(dev->base_addr, EEPRO_IO_EXTENT);
-       return -ENODEV;
+       return err;
 }
 
 /* Open/initialize the board.  This is called (in the current kernel)
                dev->irq = irq[i];
 
                if (do_eepro_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_eepro[n_eepro++] = dev;
-                               continue;
-                       }
-                       release_region(dev->base_addr, EEPRO_IO_EXTENT);
+                       dev_eepro[n_eepro++] = dev;
+                       continue;
                }
                free_netdev(dev);
                break;
 
        netdev_boot_setup_check(dev);
 
        err = do_express_probe(dev);
-       if (!err) {
-               err = register_netdev(dev);
-               if (!err)
-                       return dev;
-       }
+       if (!err)
+               return dev;
        free_netdev(dev);
        return ERR_PTR(err);
 }
        dev->set_multicast_list = &eexp_set_multicast;
        dev->tx_timeout = eexp_timeout;
        dev->watchdog_timeo = 2*HZ;
-       return 0;
+
+       return register_netdev(dev);
 }
 
 /*
                                break;
                        printk(KERN_NOTICE "eexpress.c: Module autoprobe not recommended, give io=xx.\n");
                }
-               if (do_express_probe(dev) == 0 && register_netdev(dev) == 0) {
+               if (do_express_probe(dev) == 0) {
                        dev_eexp[this_dev] = dev;
                        found++;
                        continue;
 
        err = do_es_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
        dev->poll_controller = ei_poll;
 #endif
        NS8390_init(dev, 0);
+
+       retval = register_netdev(dev);
+       if (retval)
+               goto out1;
        return 0;
 out1:
        free_irq(dev->irq, dev);
                dev->base_addr = io[this_dev];
                dev->mem_start = mem[this_dev];
                if (do_es_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_es3210[found++] = dev;
-                               continue;
-                       }
-                       cleanup_card(dev);
+                       dev_es3210[found++] = dev;
+                       continue;
                }
                free_netdev(dev);
                printk(KERN_WARNING "es3210.c: No es3210 card found (i/o = 0x%x).\n", io[this_dev]);
 
        err = do_eth16i_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       free_irq(dev->irq, dev);
-       release_region(dev->base_addr, ETH16I_IO_EXTENT);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
        dev->tx_timeout         = eth16i_timeout;
        dev->watchdog_timeo     = TX_TIMEOUT;
        spin_lock_init(&lp->lock);
+
+       retval = register_netdev(dev);
+       if (retval)
+               goto out1;
        return 0;
+out1:
+       free_irq(dev->irq, dev);
 out:
        release_region(ioaddr, ETH16I_IO_EXTENT);
        return retval;
                }
 
                if (do_eth16i_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_eth16i[found++] = dev;
-                               continue;
-                       }
-                       free_irq(dev->irq, dev);
-                       release_region(dev->base_addr, ETH16I_IO_EXTENT);
+                       dev_eth16i[found++] = dev;
+                       continue;
                }
                printk(KERN_WARNING "eth16i.c No Eth16i card found (i/o = 0x%x).\n",
                       io[this_dev]);
 
        err = do_hpp_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
        /* Leave the 8390 and HP chip reset. */
        outw(inw(ioaddr + HPP_OPTION) & ~EnableIRQ, ioaddr + HPP_OPTION);
 
+       retval = register_netdev(dev);
+       if (retval)
+               goto out;
        return 0;
 out:
        release_region(ioaddr, HP_IO_EXTENT);
                dev->irq = irq[this_dev];
                dev->base_addr = io[this_dev];
                if (do_hpp_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_hpp[found++] = dev;
-                               continue;
-                       }
-                       cleanup_card(dev);
+                       dev_hpp[found++] = dev;
+                       continue;
                }
                free_netdev(dev);
                printk(KERN_WARNING "hp-plus.c: No HP-Plus card found (i/o = 0x%x).\n", io[this_dev]);
 
        err = do_hp_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
        ei_status.block_output = &hp_block_output;
        hp_init_card(dev);
 
+       retval = register_netdev(dev);
+       if (retval)
+               goto out1;
        return 0;
+out1:
+       free_irq(dev->irq, dev);
 out:
        release_region(ioaddr, HP_IO_EXTENT);
        return retval;
                dev->irq = irq[this_dev];
                dev->base_addr = io[this_dev];
                if (do_hp_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_hp[found++] = dev;
-                               continue;
-                       }
-                       cleanup_card(dev);
+                       dev_hp[found++] = dev;
+                       continue;
                }
                free_netdev(dev);
                printk(KERN_WARNING "hp.c: No HP card found (i/o = 0x%x).\n", io[this_dev]);
 
        if (err)
                goto out;
 
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
- out1:
-       release_region(dev->base_addr, HP100_REGION_SIZE);
  out:
        free_netdev(dev);
        return ERR_PTR(err);
                printk("Warning! Link down.\n");
        }
 
+       err = register_netdev(dev);
+       if (err)
+               goto out3;
+
        return 0;
+out3:
+       if (local_mode == 1)
+               pci_free_consistent(lp->pci_dev, MAX_RINGSIZE + 0x0f, 
+                                   lp->page_vaddr_algn, 
+                                   virt_to_whatever(dev, lp->page_vaddr_algn));
+       if (mem_ptr_virt)
+               iounmap(mem_ptr_virt);
 out2:
        release_region(ioaddr, HP100_REGION_SIZE);
 out1:
-       return -ENODEV;
+       return err;
 }
 
 /* This procedure puts the card into a stable init state */
        if (err)
                goto out1;
 
-       err = register_netdev(dev);
-       if (err)
-               goto out2;
-       
 #ifdef HP100_DEBUG
        printk("hp100: %s: EISA adapter found at 0x%x\n", dev->name, 
               dev->base_addr);
 #endif
        gendev->driver_data = dev;
        return 0;
- out2:
-       release_region(dev->base_addr, HP100_REGION_SIZE);
  out1:
        free_netdev(dev);
        return err;
        err = hp100_probe1(dev, ioaddr, HP100_BUS_PCI, pdev);
        if (err) 
                goto out1;
-       err = register_netdev(dev);
-       if (err)
-               goto out2;
        
 #ifdef HP100_DEBUG
        printk("hp100: %s: PCI adapter found at 0x%x\n", dev->name, ioaddr);
 #endif
        pci_set_drvdata(pdev, dev);
        return 0;
- out2:
-       release_region(dev->base_addr, HP100_REGION_SIZE);
  out1:
        free_netdev(dev);
  out0:
                SET_MODULE_OWNER(dev);
 
                err = hp100_isa_probe(dev, hp100_port[i]);
-               if (!err) {
-                       err = register_netdev(dev);
-                       if (!err) 
-                               hp100_devlist[cards++] = dev;
-                       else
-                               release_region(dev->base_addr, HP100_REGION_SIZE);
-               }
-
-               if (err)
+               if (!err)
+                       hp100_devlist[cards++] = dev;
+               else
                        free_netdev(dev);
        }
 
 
        err = do_netcard_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
 
         dev->tx_timeout                = &net_tx_timeout;
         dev->watchdog_timeo    = MY_TX_TIMEOUT; 
+
+       err = register_netdev(dev);
+       if (err)
+               goto out2;
        return 0;
+out2:
+#ifdef jumpered_dma
+       free_dma(dev->dma);
+#endif
 out1:
 #ifdef jumpered_interrupts
        free_irq(dev->irq, dev);
        dev->dma       = dma;
        dev->mem_start = mem;
        if (do_netcard_probe(dev) == 0) {
-               if (register_netdev(dev) == 0)
-                       this_device = dev;
-                       return 0;
-               }
-               cleanup_card(dev);
+               this_device = dev;
+               return 0;
        }
        free_netdev(dev);
        return -ENXIO;
 
                dev->base_addr = io[this_dev];
                dev->dma = dma[this_dev];
                if (do_lance_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_lance[found++] = dev;
-                               continue;
-                       }
-                       cleanup_card(dev);
+                       dev_lance[found++] = dev;
+                       continue;
                }
                free_netdev(dev);
                break;
        err = do_lance_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
        dev->tx_timeout = lance_tx_timeout;
        dev->watchdog_timeo = TX_TIMEOUT;
 
+       err = register_netdev(dev);
+       if (err)
+               goto out_dma;
        return 0;
 out_dma:
        if (dev->dma != 4)
 
        err = do_lne390_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
        dev->poll_controller = ei_poll;
 #endif
        NS8390_init(dev, 0);
+
+       ret = register_netdev(dev);
+       if (ret)
+               goto unmap;
        return 0;
+unmap:
+       if (ei_status.reg0)
+               iounmap((void *)dev->mem_start);
 cleanup:
        free_irq(dev->irq, dev);
        return ret;
                dev->base_addr = io[this_dev];
                dev->mem_start = mem[this_dev];
                if (do_lne390_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_lne[found++] = dev;
-                               continue;
-                       }
-                       cleanup_card(dev);
+                       dev_lne[found++] = dev;
+                       continue;
                }
                free_netdev(dev);
                printk(KERN_WARNING "lne390.c: No LNE390 card found (i/o = 0x%x).\n", io[this_dev]);
 
        err = do_ne_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
        dev->poll_controller = ei_poll;
 #endif
        NS8390_init(dev, 0);
-       return 0;
 
+       ret = register_netdev(dev);
+       if (ret)
+               goto out_irq;
+       return 0;
+out_irq:
+       free_irq(dev->irq, dev);
 err_out:
        release_region(ioaddr, NE_IO_EXTENT);
        return ret;
                err = init_reg_offset(dev, dev->base_addr);
                if (!err) {
                        if (do_ne_probe(dev) == 0) {
-                               if (register_netdev(dev) == 0) {
-                                       dev_ne[found++] = dev;
-                                       continue;
-                               }
-                               cleanup_card(dev);
+                               dev_ne[found++] = dev;
+                               continue;
                        }
                }
                free_netdev(dev);
 
        err = do_ne_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
        dev->poll_controller = ei_poll;
 #endif
        NS8390_init(dev, 0);
+
+       ret = register_netdev(dev);
+       if (ret)
+               goto out_irq;
        return 0;
 
+out_irq:
+       free_irq(dev->irq, dev);
 err_out:
        release_region(ioaddr, NE_IO_EXTENT);
        return ret;
                dev->mem_end = bad[this_dev];
                dev->base_addr = io[this_dev];
                if (do_ne_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_ne[found++] = dev;
-                               continue;
-                       }
-                       cleanup_card(dev);
+                       dev_ne[found++] = dev;
+                       continue;
                }
                free_netdev(dev);
                if (found)
 
        err = do_ne2_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
        dev->poll_controller = ei_poll;
 #endif
        NS8390_init(dev, 0);
+
+       retval = register_netdev(dev);
+       if (retval)
+               goto out1;
        return 0;
+out1:
+       mca_set_adapter_procfn( ei_status.priv, NULL, NULL);
+       free_irq(dev->irq, dev);
 out:
        release_region(base_addr, NE_IO_EXTENT);
        return retval;
                dev->mem_end = bad[this_dev];
                dev->base_addr = io[this_dev];
                if (do_ne2_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_ne[found++] = dev;
-                               continue;
-                       }
-                       cleanup_card(dev);
+                       dev_ne[found++] = dev;
+                       continue;
                }
                free_netdev(dev);
                break;
 
        err = do_ultra_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
 #endif
        NS8390_init(dev, 0);
 
+       retval = register_netdev(dev);
+       if (retval)
+               goto out;
        return 0;
 out:
        release_region(ioaddr, ULTRA_IO_EXTENT);
                dev->irq = irq[this_dev];
                dev->base_addr = io[this_dev];
                if (do_ultra_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_ultra[found++] = dev;
-                               continue;
-                       }
-                       cleanup_card(dev);
+                       dev_ultra[found++] = dev;
+                       continue;
                }
                free_netdev(dev);
                printk(KERN_WARNING "smc-ultra.c: No SMC Ultra card found (i/o = 0x%x).\n", io[this_dev]);
 
        err = do_wd_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       cleanup_card(dev);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
 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 */
                outb(inb(ioaddr+4)|0x80, ioaddr+4);
 #endif
 
-       return 0;
+       err = register_netdev(dev);
+       if (err)
+               free_irq(dev->irq, dev);
+       return err;
 }
 
 static int
                dev->mem_start = mem[this_dev];
                dev->mem_end = mem_end[this_dev];
                if (do_wd_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_wd[found++] = dev;
-                               continue;
-                       }
-                       cleanup_card(dev);
+                       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]);