pnp_device_detach(idev);
#endif
out:
- kfree(dev);
+ free_netdev(dev);
return err;
}
free_region:
if (vp->must_free_region)
release_region(ioaddr, vci->io_size);
- kfree (dev);
+ free_netdev(dev);
printk(KERN_ERR PFX "vortex_probe1 fails. Returns %d\n", retval);
out:
return retval;
err_out_disable:
pci_disable_device(pdev);
err_out_free:
- kfree(dev);
+ free_netdev(dev);
return rc;
}
}
if (pci_enable_device(pdev)) {
- kfree(dev);
+ free_netdev(dev);
continue;
}
if (register_netdev(dev)) {
printk(KERN_ERR "acenic: device registration failed\n");
- kfree(dev);
+ free_netdev(dev);
continue;
}
printk(KERN_ERR "%s: Driver compiled without Tigon I"
" support - NIC disabled\n", dev->name);
ace_init_cleanup(dev);
- kfree(dev);
+ free_netdev(dev);
continue;
}
#endif
* ace_allocate_descriptors() calls
* ace_init_cleanup() on error.
*/
- kfree(dev);
+ free_netdev(dev);
continue;
}
/*
* ace_init() calls ace_init_cleanup() on error.
*/
- kfree(dev);
+ free_netdev(dev);
continue;
}
iounmap((void *) lp->mmio);
err_free_dev:
- kfree(dev);
+ free_netdev(dev);
err_free_reg:
pci_release_regions(pdev);
iounmap((void *) bp->regs);
err_out_free_dev:
- kfree(dev);
+ free_netdev(dev);
err_out_free_res:
pci_release_regions(pdev);
release_OF_resource(bp->node, 0);
out1:
pmac_call_feature(PMAC_FTR_BMAC_ENABLE, bp->node, 0, 0);
- kfree(dev);
+ free_netdev(dev);
}
static int bmac_open(struct net_device *dev)
SET_MODULE_OWNER(dev);
if (register_netdev(dev) != 0) {
- kfree(dev);
+ free_netdev(dev);
return -EIO;
}
ret = -EIO;
if (register_netdev(devN)) {
- kfree(devN);
+ free_netdev(devN);
goto fail;
}
privN->chan = i+1;
err_out_dev:
#endif
- kfree (dev);
+ free_netdev (dev);
err_out_res:
pci_release_regions (pdev);
err_free_unlock:
rtnl_unlock();
- kfree(dev);
+ free_netdev(dev);
return -1;
}
#endif
pci_release_regions(pdev);
err_out_free_netdev:
- kfree(dev);
+ free_netdev(dev);
return -ENODEV;
}
\f
err_out_free_rx:
pci_free_consistent(pdev, RX_TOTAL_SIZE, np->rx_ring, np->rx_ring_dma);
err_out_free_dev:
- kfree(dev);
+ free_netdev(dev);
err_out_unmap:
#ifndef USE_IO_OPS
iounmap((void *)ioaddr);
pci_free_consistent(pdev, TX_TOTAL_SIZE, hmp->tx_ring,
hmp->tx_ring_dma);
err_out_cleardev:
- kfree (dev);
+ free_netdev (dev);
err_out_iounmap:
iounmap((char *)ioaddr);
err_out_release:
out_res:
pci_release_regions(pdev);
out_free:
- kfree(dev);
+ free_netdev(dev);
return err;
}
retval = register_netdev(netdevice);
if (retval) {
printk(KERN_WARNING __FILE__ ": register_netdevice ret'd %d\n", retval);
- kfree(netdevice);
+ free_netdev(netdevice);
return -ENODEV;
};
if (dev->id.sversion == 0x72) {
dev->base_addr = io;
dev->init = lp486e_probe;
if (register_netdev(dev) != 0) {
- kfree(dev);
+ free_netdev(dev);
return -EIO;
}
dev_lp486e = dev;
i = pci_request_regions(pdev, dev->name);
if (i) {
- kfree(dev);
+ free_netdev(dev);
return i;
}
void *mmio = ioremap (ioaddr, iosize);
if (!mmio) {
pci_release_regions(pdev);
- kfree(dev);
+ free_netdev(dev);
return -ENOMEM;
}
ioaddr = (unsigned long) mmio;
if (i) {
pci_release_regions(pdev);
unregister_netdev(dev);
- kfree(dev);
+ free_netdev(dev);
pci_set_drvdata(pdev, NULL);
return i;
}
struct net_device *dev;
struct pcnet32_access *a = NULL;
u8 promaddr[6];
+ int ret = -ENODEV;
/* reset the chip */
pcnet32_wio_reset(ioaddr);
pcnet32_dwio_reset(ioaddr);
if (pcnet32_dwio_read_csr(ioaddr, 0) == 4 && pcnet32_dwio_check(ioaddr)) {
a = &pcnet32_dwio;
- } else {
- release_region(ioaddr, PCNET32_TOTAL_SIZE);
- return -ENODEV;
- }
+ } else
+ goto err_release_region;
}
chip_version = a->read_csr(ioaddr, 88) | (a->read_csr(ioaddr,89) << 16);
if (pcnet32_debug > 2)
printk(KERN_INFO " PCnet chip version is %#x.\n", chip_version);
- if ((chip_version & 0xfff) != 0x003) {
- release_region(ioaddr, PCNET32_TOTAL_SIZE);
- return -ENODEV;
- }
+ if ((chip_version & 0xfff) != 0x003)
+ goto err_release_region;
/* initialize variables */
fdx = mii = fset = dxsuflo = ltint = 0;
default:
printk(KERN_INFO PFX "PCnet version %#x, no PCnet32 chip.\n",
chip_version);
- release_region(ioaddr, PCNET32_TOTAL_SIZE);
- return -ENODEV;
+ goto err_release_region;
}
/*
dev = alloc_etherdev(0);
if(!dev) {
- release_region(ioaddr, PCNET32_TOTAL_SIZE);
- return -ENOMEM;
+ ret = -ENOMEM;
+ goto err_release_region;
}
SET_NETDEV_DEV(dev, &pdev->dev);
dev->base_addr = ioaddr;
/* pci_alloc_consistent returns page-aligned memory, so we do not have to check the alignment */
if ((lp = pci_alloc_consistent(pdev, sizeof(*lp), &lp_dma_addr)) == NULL) {
- release_region(ioaddr, PCNET32_TOTAL_SIZE);
- return -ENOMEM;
+ ret = -ENOMEM;
+ goto err_free_netdev;
}
memset(lp, 0, sizeof(*lp));
if (!a) {
printk(KERN_ERR PFX "No access methods\n");
- pci_free_consistent(lp->pci_dev, sizeof(*lp), lp, lp->dma_addr);
- release_region(ioaddr, PCNET32_TOTAL_SIZE);
- return -ENODEV;
+ ret = -ENODEV;
+ goto err_free_consistent;
}
lp->a = *a;
mdelay (1);
dev->irq = probe_irq_off (irq_mask);
- if (dev->irq)
- printk(", probed IRQ %d.\n", dev->irq);
- else {
+ if (!dev->irq) {
printk(", failed to detect IRQ line.\n");
- pci_free_consistent(lp->pci_dev, sizeof(*lp), lp, lp->dma_addr);
- release_region(ioaddr, PCNET32_TOTAL_SIZE);
- return -ENODEV;
+ ret = -ENODEV;
+ goto err_free_consistent;
}
+ printk(", probed IRQ %d.\n", dev->irq);
}
/* Set the mii phy_id so that we can query the link state */
printk(KERN_INFO "%s: registered as %s\n",dev->name, lp->name);
cards_found++;
return 0;
+
+err_free_consistent:
+ pci_free_consistent(lp->pci_dev, sizeof(*lp), lp, lp->dma_addr);
+err_free_netdev:
+ free_netdev(dev);
+err_release_region:
+ release_region(ioaddr, PCNET32_TOTAL_SIZE);
+ return ret;
}
pci_disable_device(pdev);
err_out:
- kfree(dev);
+ free_netdev(dev);
return rc;
}
iounmap(ioaddr);
pci_release_regions(pdev);
pci_disable_device(pdev);
- kfree(dev);
+ free_netdev(dev);
return rc;
}
pci_free_consistent (pdev, MSG_BUF_SIZE, pDpa->msgbuf,
pDpa->msgbuf_dma);
err_out_free_dev:
- kfree (dev);
+ free_netdev (dev);
err_out:
card_idx--;
return error;
error = register_netdev(dev);
if (error)
- goto out_release_regions;
+ goto out_free_netdev;
return 0;
+ out_free_netdev:
+ free_netdev(dev);
out_release_regions:
release_region(ioaddr[1], 16);
out_release_region0:
rc = pci_set_dma_mask(pdev, 0xffffffffULL);
if (rc)
- goto err_out;
+ goto err_out_disable;
mmio_start = pci_resource_start(pdev, 0);
mmio_end = pci_resource_end(pdev, 0);
printk(KERN_ERR PFX
"region #0 not an MMIO resource, aborting\n");
rc = -ENODEV;
- goto err_out;
+ goto err_out_disable;
}
// check for weird/broken PCI region reporting
if (mmio_len < SiS190_MIN_IO_SIZE) {
printk(KERN_ERR PFX "Invalid PCI region size(s), aborting\n");
rc = -ENODEV;
- goto err_out;
+ goto err_out_disable;
}
rc = pci_request_regions(pdev, dev->name);
if (rc)
- goto err_out;
+ goto err_out_disable;
// enable PCI bus-mastering
pci_set_master(pdev);
err_out_free_res:
pci_release_regions(pdev);
-err_out:
+err_out_disable:
pci_disable_device(pdev);
- kfree(dev);
+err_out:
+ free_netdev(dev);
return rc;
}
iounmap(ioaddr);
pci_release_regions(pdev);
pci_disable_device(pdev);
- kfree(dev);
+ free_netdev(dev);
return rc;
}
pci_set_drvdata(pci_dev, NULL);
pci_release_regions(pci_dev);
err_out:
- kfree(net_dev);
+ free_netdev(net_dev);
return ret;
}
struct mca_device *mca_dev = to_mca_device(gen_dev);
char slot = mca_dev->slot;
unsigned char pos2 = 0xff, pos3 = 0xff, pos4 = 0xff, pos5 = 0xff;
- int i;
+ int i, rc;
int adapter = mca_dev->index;
int tbase = 0;
int tirq = 0;
SET_MODULE_OWNER(dev);
SET_NETDEV_DEV(dev, gen_dev);
- if((i = register_netdev(dev)) != 0)
- return i;
+ rc = register_netdev(dev);
+ if (rc)
+ goto err_free_netdev;
printk(KERN_INFO "%s: %s found in slot %d\n",
dev->name, smc_mca_adapter_names[adapter], slot + 1);
}
}
- if (dev->mem_start == 0) /* sanity check, shouldn't happen */
- return -ENODEV;
+ /* sanity check, shouldn't happen */
+ if (dev->mem_start == 0) {
+ rc = -ENODEV;
+ goto err_unregister_netdev;
+ }
- if (!request_region(ioaddr, ULTRA_IO_EXTENT, dev->name))
- return -EBUSY;
+ rc = request_region(ioaddr, ULTRA_IO_EXTENT, dev->name);
+ if (rc)
+ goto err_unregister_netdev;
reg4 = inb(ioaddr + 4) & 0x7f;
outb(reg4, ioaddr + 4);
/* Allocate dev->priv and fill in 8390 specific dev fields.
*/
- if (ethdev_init(dev)) {
+ rc = ethdev_init(dev);
+ if (rc) {
printk (", no memory for dev->priv.\n");
- release_region(ioaddr, ULTRA_IO_EXTENT);
- return -ENOMEM;
+ goto err_release_region;
}
gen_dev->driver_data = dev;
NS8390_init(dev, 0);
return 0;
+
+err_release_region:
+ release_region(ioaddr, ULTRA_IO_EXTENT);
+err_unregister_netdev:
+ unregister_netdev(dev);
+err_free_netdev:
+ free_netdev(dev);
+ return rc;
}
static int ultramca_open(struct net_device *dev)
err_out_free_res:
pci_release_regions (pdev);
err_out_free_netdev:
- kfree(dev);
+ free_netdev(dev);
return -ENODEV;
}
#endif
pci_release_regions(pdev);
err_out_netdev:
- kfree (dev);
+ free_netdev (dev);
return -ENODEV;
}
if (err) {
printk(KERN_ERR PFX "No usable DMA configuration, "
"aborting.\n");
- return err;
+ goto err_disable_device;
}
pci_using_dac = 0;
}
if ((pci_resource_flags(pdev, 0) & IORESOURCE_IO) != 0) {
printk(KERN_ERR PFX "Cannot find proper PCI device "
"base address, aborting.\n");
- return -ENODEV;
+ err = -ENODEV;
+ goto err_disable_device;
}
dev = alloc_etherdev(sizeof(*gp));
if (!dev) {
printk(KERN_ERR PFX "Etherdev alloc failed, aborting.\n");
- return -ENOMEM;
+ err = -ENOMEM;
+ goto err_disable_device;
}
SET_MODULE_OWNER(dev);
SET_NETDEV_DEV(dev, &pdev->dev);
gp = dev->priv;
- if (pci_request_regions(pdev, dev->name)) {
+ err = pci_request_regions(pdev, dev->name);
+ if (err) {
printk(KERN_ERR PFX "Cannot obtain PCI resources, "
"aborting.\n");
goto err_out_free_netdev;
if (gp->regs == 0UL) {
printk(KERN_ERR PFX "Cannot map device registers, "
"aborting.\n");
+ err = -EIO;
goto err_out_free_res;
}
/* By default, we start with autoneg */
gp->want_autoneg = 1;
- if (gem_check_invariants(gp))
+ if (gem_check_invariants(gp)) {
+ err = -ENODEV;
goto err_out_iounmap;
+ }
/* It is guaranteed that the returned buffer will be at least
* PAGE_SIZE aligned.
if (!gp->init_block) {
printk(KERN_ERR PFX "Cannot allocate init block, "
"aborting.\n");
+ err = -ENOMEM;
goto err_out_iounmap;
}
if (register_netdev(dev)) {
printk(KERN_ERR PFX "Cannot register net device, "
"aborting.\n");
+ err = -ENOMEM;
goto err_out_free_consistent;
}
pci_release_regions(pdev);
err_out_free_netdev:
- kfree(dev);
-
- return -ENODEV;
+ free_netdev(dev);
+err_disable_device:
+ pci_disable_device(pdev);
+ return err;
}
sbus_iounmap(hp->tcvregs, TCVR_REG_SIZE);
err_out_free_netdev:
- kfree(dev);
+ free_netdev(dev);
err_out:
return err;
if (qp != NULL)
qp->happy_meals[qfe_slot] = NULL;
- kfree(dev);
+ free_netdev(dev);
err_out:
return err;
i = 4;
out:
while (i--)
- kfree(qe_devs[i]);
+ free_netdev(qe_devs[i]);
return res;
}
iounmap((void *) tp->regs);
err_out_free_dev:
- kfree(dev);
+ free_netdev(dev);
err_out_free_res:
pci_release_regions(pdev);
pci_free_consistent(priv->pciDev, priv->dmaSize, priv->dmaStorage,
priv->dmaStorageDMA );
err_out_free_dev:
- kfree(dev);
+ free_netdev(dev);
err_out_regions:
if (pdev)
pci_release_regions(pdev);
release_region( dev->base_addr, 0x10);
unregister_netdev( dev );
TLan_Eisa_Devices = priv->nextDevice;
- kfree( dev );
+ free_netdev( dev );
tlan_have_eisa--;
}
}
error_out_regions:
pci_release_regions(pdev);
error_out_dev:
- kfree(dev);
+ free_netdev(dev);
error_out:
return err;
}
#endif
pci_release_regions(pdev);
err_out_free_netdev:
- kfree (dev);
+ free_netdev (dev);
err_out:
return -ENODEV;
}
#endif
pci_release_regions(pdev);
err_out_free_netdev:
- kfree (dev);
+ free_netdev (dev);
return -ENODEV;
}