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