static void igbuio_pci_remove(struct pci_dev *dev) { struct rte_uio_pci_dev *udev = pci_get_drvdata(dev); struct net_device *netdev; struct net_adapter *adapter; /* unregister device from netdev */ netdev = udev->adapter->netdev; adapter = netdev_priv(netdev); if (udev->adapter->netdev_registered) { unregister_netdev(netdev); udev->adapter->netdev_registered = false; } switch (udev->adapter->type) { case IXGBE: iounmap(udev->adapter->hw._ixgbe_hw.hw_addr); break; case IGB: iounmap(udev->adapter->hw._ixgbe_hw.hw_addr); break; } free_netdev(netdev); sysfs_remove_group(&dev->dev.kobj, &dev_attr_grp); uio_unregister_device(&udev->info); igbuio_pci_release_iomem(&udev->info); if (udev->mode == RTE_INTR_MODE_MSIX) pci_disable_msix(dev); pci_release_regions(dev); pci_disable_device(dev); pci_set_drvdata(dev, NULL); kfree(udev); }
static void __devexit mrf_remove(struct pci_dev *dev) { struct uio_info *info = pci_get_drvdata(dev); struct mrf_priv *priv = container_of(info, struct mrf_priv, uio); #ifdef CONFIG_PARPORT_NOT_PC mrf_pp_cleanup(priv); #endif #ifdef CONFIG_GENERIC_GPIO mrf_gpio_cleanup(priv); #endif #if defined(CONFIG_GENERIC_GPIO) || defined(CONFIG_PARPORT_NOT_PC) { void __iomem *plx = info->mem[0].internal_addr; u32 val = ioread32(plx + GPIOC); // Disable output drivers for TCLK, TMS, and TDI val &= ~GPIOC_pin_dir(0); val &= ~GPIOC_pin_dir(1); val &= ~GPIOC_pin_dir(3); iowrite32(val, plx + GPIOC); } #endif uio_unregister_device(info); pci_set_drvdata(dev, NULL); iounmap(info->mem[0].internal_addr); iounmap(info->mem[2].internal_addr); pci_release_regions(dev); pci_disable_device(dev); kzfree(priv); dev_info(&dev->dev, "MRF Cleaned up\n"); }
static int drv_kpart_remove(struct device *dev) { printk(KERN_ERR "drv_kpart_remove"); kfree((void *)kpart_info.mem[0].addr); uio_unregister_device(&kpart_info); return 0; }
static int __devexit pruss_remove(struct platform_device *dev) { int count = 0; struct uio_info **info; info = (struct uio_info **)platform_get_drvdata(dev); for (count = 0; count < PRUSS_INSTANCE; count ++) { uio_unregister_device(info[count]); if (info[count]->name) kfree (info[count]->name); } iounmap(info[0]->mem[0].internal_addr); iounmap(info[0]->mem[1].internal_addr); if (ddr_virt_addr) dma_free_coherent (&dev->dev, info[0]->mem[2].size, info[0]->mem[2].internal_addr, info[0]->mem[2].addr ); for (count = 0; count < PRUSS_INSTANCE; count ++) { if (info[count]) kfree(info[count]); } platform_set_drvdata(dev, NULL); if(pruss_clk != NULL) clk_put(pruss_clk); if (ecap0_clk != NULL) clk_put (ecap0_clk); return 0; }
/** * xapm_remove - Driver remove function * @pdev: Pointer to the platform_device structure * * Always returns '0' */ static int xapm_remove(struct platform_device *pdev) { struct xapm_dev *xapm = platform_get_drvdata(pdev); uio_unregister_device(&xapm->info); return 0; }
static int uio_pdrv_genirq_remove(struct platform_device *pdev) { struct uio_pdrv_genirq_platdata *priv = platform_get_drvdata(pdev); uio_unregister_device(priv->uioinfo); pm_runtime_disable(&pdev->dev); kfree(priv); return 0; }
static int uio_ubicom32ring_remove(struct platform_device *pdev) { struct uio_ubicom32ring_data *priv = platform_get_drvdata(pdev); uio_unregister_device(priv->uioinfo); kfree(priv->uioinfo); kfree(priv); return 0; }
static void remove(struct pci_dev *const pci_dev) { struct uio_info *const info = pci_get_drvdata(pci_dev); uio_unregister_device(info); kfree(info); pci_release_regions(pci_dev); pci_disable_device(pci_dev); }
static int uio_pdrv_remove(struct platform_device *pdev) { struct uio_platdata *pdata = platform_get_drvdata(pdev); uio_unregister_device(pdata->uioinfo); kfree(pdata); return 0; }
static int uio_pdrv_genirq_remove(struct platform_device *pdev) { struct uio_pdrv_genirq_platdata *priv = platform_get_drvdata(pdev); uio_unregister_device(priv->uioinfo); priv->uioinfo->handler = NULL; priv->uioinfo->irqcontrol = NULL; kfree(priv); return 0; }
static void hilscher_pci_remove(struct pci_dev *dev) { struct uio_info *info = pci_get_drvdata(dev); uio_unregister_device(info); pci_release_regions(dev); pci_disable_device(dev); pci_set_drvdata(dev, NULL); iounmap(info->mem[0].internal_addr); kfree (info); }
static int __devexit smx_ce_remove(struct platform_device *dev) { struct uio_info *info = platform_get_drvdata(dev); uio_unregister_device(info); platform_set_drvdata(dev, NULL); iounmap(info->mem[0].internal_addr); kfree(info); return 0; }
static int xillybus_lite_of_remove(struct platform_device *op) { struct device *dev = &op->dev; struct xillybus_lite_info *myinfo = dev_get_drvdata(dev); uio_unregister_device(&myinfo->info); release_mem_region(myinfo->res.start, resource_size(&myinfo->res)); kfree(myinfo); return 0; }
static void netx_pci_remove(struct pci_dev *dev) { struct uio_info *info = pci_get_drvdata(dev); /* Disable all interrupts */ iowrite32(0, info->mem[0].internal_addr + DPM_HOST_INT_EN0); uio_unregister_device(info); pci_release_regions(dev); pci_disable_device(dev); iounmap(info->mem[0].internal_addr); kfree(info); }
static void igbuio_pci_remove(struct pci_dev *dev) { struct rte_uio_pci_dev *udev = pci_get_drvdata(dev); mutex_destroy(&udev->lock); sysfs_remove_group(&dev->dev.kobj, &dev_attr_grp); uio_unregister_device(&udev->info); igbuio_pci_release_iomem(&udev->info); pci_disable_device(dev); pci_set_drvdata(dev, NULL); kfree(udev); }
static int __devexit mbref_uio_of_remove(struct of_device *op) { struct mbref_uio_platdata *priv = dev_get_drvdata(&op->dev); uio_unregister_device(priv->uioinfo); if (priv->uioinfo->irq != UIO_IRQ_NONE) irq_dispose_mapping(priv->uioinfo->irq); kfree(priv->uioinfo); kfree(priv); return 0; }
static void igbuio_pci_remove(struct pci_dev *dev) { struct rte_uio_pci_dev *udev = pci_get_drvdata(dev); sysfs_remove_group(&dev->dev.kobj, &dev_attr_grp); uio_unregister_device(&udev->info); igbuio_pci_release_iomem(&udev->info); if (udev->mode == RTE_INTR_MODE_MSIX) pci_disable_msix(dev); pci_release_regions(dev); pci_disable_device(dev); pci_set_drvdata(dev, NULL); kfree(udev); }
static int hv_uio_remove(struct hv_device *dev) { struct hv_uio_private_data *pdata = hv_get_drvdata(dev); if (!pdata) return 0; uio_unregister_device(&pdata->info); hv_uio_cleanup(dev, pdata); hv_set_drvdata(dev, NULL); vmbus_close(dev->channel); kfree(pdata); return 0; }
static void sercos3_pci_remove(struct pci_dev *dev) { struct uio_info *info = pci_get_drvdata(dev); int i; uio_unregister_device(info); pci_release_regions(dev); pci_disable_device(dev); for (i = 0; i < 5; i++) { if (info->mem[i].internal_addr) iounmap(info->mem[i].internal_addr); } kfree(info->priv); kfree(info); }
static int mvisp_remove(struct platform_device *pdev) { struct uio_mvisp_dev *cdev = platform_get_drvdata(pdev); uio_unregister_device(&cdev->uio_info); free_pages((unsigned long)cdev->uio_info.mem[1].internal_addr, get_order(VDEC_WORKING_BUFFER_SIZE)); iounmap(cdev->uio_info.mem[0].internal_addr); clk_put(cdev->clk); kfree(cdev); return 0; }
static void mf624_pci_remove(struct pci_dev *dev) { struct uio_info *info = pci_get_drvdata(dev); mf624_disable_interrupt(ALL, info); uio_unregister_device(info); pci_release_regions(dev); pci_disable_device(dev); iounmap(info->mem[0].internal_addr); iounmap(info->mem[1].internal_addr); iounmap(info->mem[2].internal_addr); kfree(info); }
static int sch_gpio_remove(struct platform_device *pdev) { int err = 0; struct resource *res; struct sch_gpio *chip = platform_get_drvdata(pdev); if (gpio_ba) { if (info != NULL) { uio_unregister_device(info); kfree(info); } sch_gpio_resume_irqs_deinit(chip, sch_gpio_resume.ngpio); sch_gpio_core_irqs_deinit(chip, sch_gpio_core.ngpio); if (irq_num > 0) free_irq(irq_num, chip); platform_device_unregister(&qrk_gpio_restrict_pdev); irq_free_descs(chip->irq_base_resume, sch_gpio_resume.ngpio); irq_free_descs(chip->irq_base_core, sch_gpio_core.ngpio); gpiochip_remove(&sch_gpio_resume); gpiochip_remove(&sch_gpio_core); res = platform_get_resource(pdev, IORESOURCE_IO, 0); release_region(res->start, resource_size(res)); gpio_ba = 0; } sch_gpio_resume_restore_state(&(chip->initial_resume)); sch_gpio_core_restore_state(&(chip->initial_core)); kfree(chip); chip_ptr = 0; return err; }
static int uio_pdrv_hm2reg_io_remove(struct platform_device *pdev) { struct uio_pdrv_genirq_platdata *priv = platform_get_drvdata(pdev); uio_unregister_device(priv->uioinfo); pm_runtime_disable(&pdev->dev); priv->uioinfo->handler = NULL; priv->uioinfo->irqcontrol = NULL; /* kfree uioinfo for OF */ if (pdev->dev.of_node) kfree(priv->uioinfo); kfree(priv); return 0; }
static void remove(struct pci_dev *pdev) { struct uio_info *info = pci_get_drvdata(pdev); iowrite8(INT_DISABLE, info->priv + INT_MASK_ADDR); iowrite32(INT_DISABLE, info->priv + INT_ENABLE_ADDR); ioread8(info->priv + MAILBOX); uio_unregister_device(info); pci_release_regions(pdev); pci_disable_device(pdev); pci_set_drvdata(pdev, NULL); iounmap(info->priv); kfree(info); }
static void ivshmem_pci_remove(struct pci_dev *dev) { struct ivshmem_info *ivshmem_info = pci_get_drvdata(dev); struct uio_info *info = ivshmem_info->uio; pci_set_drvdata(dev, NULL); uio_unregister_device(info); if (ivshmem_info->nvectors) { free_msix_vectors(ivshmem_info, ivshmem_info->nvectors); pci_disable_msix(dev); kfree(ivshmem_info->msix_entries); kfree(ivshmem_info->msix_names); } iounmap(info->mem[0].internal_addr); pci_release_regions(dev); pci_disable_device(dev); kfree(info); kfree(ivshmem_info); }
static int uio_fsl_elbc_gpcm_remove(struct platform_device *pdev) { struct uio_info *info = platform_get_drvdata(pdev); struct fsl_elbc_gpcm *priv = info->priv; device_remove_file(priv->dev, &dev_attr_reg_or); device_remove_file(priv->dev, &dev_attr_reg_br); platform_set_drvdata(pdev, NULL); uio_unregister_device(info); if (priv->shutdown) priv->shutdown(info, false); iounmap(info->mem[0].internal_addr); kfree(info->mem[0].name); kfree(info->name); kfree(info); kfree(priv); return 0; }
static void pruss_cleanup(struct platform_device *dev, struct uio_pruss_dev *gdev) { int cnt; struct uio_info *p = gdev->info; for (cnt = 0; cnt < MAX_PRUSS_EVT; cnt++, p++) { uio_unregister_device(p); kfree(p->name); } iounmap(gdev->prussio_vaddr); if (gdev->ddr_vaddr) { dma_free_coherent(&dev->dev, extram_pool_sz, gdev->ddr_vaddr, gdev->ddr_paddr); } if (gdev->sram_vaddr) gen_pool_free(davinci_gen_pool, (unsigned long)gdev->sram_vaddr, sram_pool_sz); kfree(gdev->info); clk_put(gdev->pruss_clk); kfree(gdev); }
static int drv_kpart_remove(struct device *dev) { uio_unregister_device(&kpart_info); return 0; }
static int drv_kpart_remove(struct device *dev) { printk(KERN_ERR "drv_kpart_remove"); uio_unregister_device(&kpart_info); return 0; }
static int __devinit pruss_probe(struct platform_device *dev) { int ret = -ENODEV; int count = 0; struct resource *regs_pruram, *regs_l3ram, *regs_ddr; char *string; /* Power on PRU in case its not done as part of boot-loader */ pruss_clk = clk_get(&dev->dev, "pruss"); if (IS_ERR(pruss_clk)) { dev_err(&dev->dev, "no pruss clock available\n"); ret = PTR_ERR(pruss_clk); pruss_clk = NULL; return ret; } else { clk_enable (pruss_clk); } ecap0_clk = clk_get(&dev->dev, "ecap0"); if (IS_ERR(ecap0_clk)) { dev_err(&dev->dev, "no ecap0 clock available\n"); ret = PTR_ERR(ecap0_clk); ecap0_clk = NULL; return ret; } else { clk_enable (ecap0_clk); } for (count = 0; count < PRUSS_INSTANCE; count ++) { info[count] = (struct uio_info *)kzalloc(sizeof (struct uio_info), GFP_KERNEL); if (!info[count]) return -ENOMEM; } regs_pruram = platform_get_resource(dev, IORESOURCE_MEM, 0); if (!regs_pruram) { dev_err(&dev->dev, "No memory resource specified\n"); goto out_free; } regs_l3ram = platform_get_resource(dev, IORESOURCE_MEM, 1); if (!regs_l3ram) { dev_err(&dev->dev, "No memory resource specified\n"); goto out_free; } regs_ddr = platform_get_resource(dev, IORESOURCE_MEM, 2); if (!regs_ddr) { dev_err(&dev->dev, "No memory resource specified\n"); goto out_free; } ddr_virt_addr = dma_alloc_coherent (&dev->dev, regs_ddr->end-regs_ddr->start+1, &ddr_phy_addr, GFP_KERNEL|GFP_DMA); for (count = 0; count < PRUSS_INSTANCE; count ++) { info[count]->mem[0].addr = regs_pruram->start; if (!info[count]->mem[0].addr) { dev_err(&dev->dev, "Invalid memory resource\n"); break; } info[count]->mem[0].size = regs_pruram->end - regs_pruram->start + 1; info[count]->mem[0].internal_addr = ioremap(regs_pruram->start, info[count]->mem[0].size); if (!info[count]->mem[0].internal_addr) { dev_err(&dev->dev, "Can't remap memory address range\n"); break; } info[count]->mem[0].memtype = UIO_MEM_PHYS; info[count]->mem[1].addr = regs_l3ram->start; if (!info[count]->mem[1].addr) { dev_err(&dev->dev, "Invalid memory resource\n"); break; } info[count]->mem[1].size = regs_l3ram->end - regs_l3ram->start + 1; info[count]->mem[1].internal_addr = ioremap(regs_l3ram->start, info[count]->mem[1].size); if (!info[count]->mem[1].internal_addr) { dev_err(&dev->dev, "Can't remap memory address range\n"); break; } info[count]->mem[1].memtype = UIO_MEM_PHYS; info[count]->mem[2].size = regs_ddr->end - regs_ddr->start + 1; if (!(info[count]->mem[2].size-1)) { dev_err(&dev->dev, "Invalid memory resource\n"); break; } info[count]->mem[2].internal_addr = ddr_virt_addr; if (!info[count]->mem[2].internal_addr) { dev_err(&dev->dev, "Can't remap memory address range\n"); break; } info[count]->mem[2].addr = ddr_phy_addr; info[count]->mem[2].memtype = UIO_MEM_PHYS; string = kzalloc(20, GFP_KERNEL); sprintf (string, "pruss_evt%d", count); info[count]->name = string; info[count]->version = "0.01"; /* Register PRUSS IRQ lines */ info[count]->irq = IRQ_DA8XX_EVTOUT0+count; info[count]->irq_flags = IRQF_SHARED; info[count]->handler = pruss_handler; ret = uio_register_device(&dev->dev, info[count]); if (ret < 0) break; } platform_set_drvdata(dev, info); if (ret < 0) { if (ddr_virt_addr) dma_free_coherent (&dev->dev, regs_ddr->end - regs_ddr->start + 1, ddr_virt_addr, ddr_phy_addr); while (count --) { uio_unregister_device (info[count]); if (info[count]->name) kfree (info[count]->name); iounmap(info[count]->mem[0].internal_addr); } } else { return 0; } out_free: for (count = 0; count < PRUSS_INSTANCE; count ++) { if (info[count]) kfree(info[count]); } if(pruss_clk != NULL) clk_put(pruss_clk); if (ecap0_clk != NULL) clk_put (ecap0_clk); return ret; }