static int sch_gpio_remove(struct platform_device *pdev) { struct resource *res; if (gpio_ba) { int err; err = gpiochip_remove(&sch_gpio_core); if (err) dev_err(&pdev->dev, "%s failed, %d\n", "gpiochip_remove()", err); err = gpiochip_remove(&sch_gpio_resume); if (err) dev_err(&pdev->dev, "%s failed, %d\n", "gpiochip_remove()", err); res = platform_get_resource(pdev, IORESOURCE_IO, 0); release_region(res->start, resource_size(res)); gpio_ba = 0; return err; } return 0; }
int sh_pfc_unregister_gpiochip(struct sh_pfc *pfc) { gpiochip_remove(&pfc->gpio->gpio_chip); #ifdef CONFIG_SUPERH gpiochip_remove(&pfc->func->gpio_chip); #endif return 0; }
static int gpio_apu2_remove (struct platform_device *dev) { #if LINUX_VERSION_CODE < KERNEL_VERSION(3,18,0) int ret; ret = gpiochip_remove (&gpio_apu2_chip); #else /* LINUX_VERSION_CODE < KERNEL_VERSION(3,18,0) */ gpiochip_remove (&gpio_apu2_chip); #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,18,0) */ return 0; }
static int vprbrd_gpio_remove(struct platform_device *pdev) { struct vprbrd_gpio *vb_gpio = platform_get_drvdata(pdev); int ret; ret = gpiochip_remove(&vb_gpio->gpiob); if (ret == 0) ret = gpiochip_remove(&vb_gpio->gpioa); return ret; }
static int kempld_gpio_remove(struct platform_device *pdev) { struct kempld_gpio_data *gpio = platform_get_drvdata(pdev); gpiochip_remove(&gpio->chip); return 0; }
static int tps6586x_gpio_remove(struct platform_device *pdev) { struct tps6586x_gpio *tps6586x_gpio = platform_get_drvdata(pdev); gpiochip_remove(&tps6586x_gpio->gpio_chip); return 0; }
static int altera_gpio_remove(struct platform_device *pdev) { unsigned int irq, i; int status; struct altera_gpio_chip *altera_gc = platform_get_drvdata(pdev); status = gpiochip_remove(&altera_gc->mmchip.gc); if (status < 0) return status; if (altera_gc->irq) { irq_dispose_mapping(altera_gc->hwirq); for (i = 0; i < altera_gc->mmchip.gc.ngpio; i++) { irq = irq_find_mapping(altera_gc->irq, i); if (irq > 0) irq_dispose_mapping(irq); } irq_domain_remove(altera_gc->irq); } irq_set_handler_data(altera_gc->hwirq, NULL); irq_set_chained_handler(altera_gc->hwirq, NULL); devm_kfree(&pdev->dev, altera_gc); return -EIO; }
void pio2_gpio_exit(struct pio2_card *card) { const char *label = card->gc.label; gpiochip_remove(&(card->gc)); kfree(label); }
static int dc_gpiochip_add(struct dc_pinmap *pmap, struct device_node *np) { struct gpio_chip *chip = &pmap->chip; int ret; chip->label = DRIVER_NAME; chip->parent = pmap->dev; chip->request = gpiochip_generic_request; chip->free = gpiochip_generic_free; chip->direction_input = dc_gpio_direction_input; chip->direction_output = dc_gpio_direction_output; chip->get = dc_gpio_get; chip->set = dc_gpio_set; chip->base = -1; chip->ngpio = PINS_COUNT; chip->of_node = np; chip->of_gpio_n_cells = 2; spin_lock_init(&pmap->lock); ret = gpiochip_add_data(chip, pmap); if (ret < 0) return ret; ret = gpiochip_add_pin_range(chip, dev_name(pmap->dev), 0, 0, PINS_COUNT); if (ret < 0) { gpiochip_remove(chip); return ret; } return 0; }
static int __devexit adp5588_gpio_remove(struct i2c_client *client) { struct adp5588_gpio_platform_data *pdata = client->dev.platform_data; struct adp5588_gpio *dev = i2c_get_clientdata(client); int ret; if (pdata->teardown) { ret = pdata->teardown(client, dev->gpio_chip.base, dev->gpio_chip.ngpio, pdata->context); if (ret < 0) { dev_err(&client->dev, "teardown failed %d\n", ret); return ret; } } if (dev->irq_base) free_irq(dev->client->irq, dev); ret = gpiochip_remove(&dev->gpio_chip); if (ret) { dev_err(&client->dev, "gpiochip_remove failed %d\n", ret); return ret; } kfree(dev); return 0; }
static int arizona_gpio_remove(struct platform_device *pdev) { struct arizona_gpio *arizona_gpio = platform_get_drvdata(pdev); gpiochip_remove(&arizona_gpio->gpio_chip); return 0; }
static int pod_gpio_remove(struct platform_device *pdev) { struct resource *resource_memory, *resource_irq; struct pod_gpio_chip *cg_chip = dev_get_drvdata(&pdev->dev); unsigned int irq; /* Remove the GPIO chip */ if (gpiochip_remove(&cg_chip->chip)) dev_err(&pdev->dev, "gpio_chip remove failed\n"); if (cg_chip->reg_base) iounmap(cg_chip->reg_base); kfree(cg_chip); resource_memory = platform_get_resource(pdev, IORESOURCE_MEM, 0); resource_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); release_mem_region(resource_memory->start, resource_size(resource_memory)); for (irq = IRQ_GPIO_POD(0) ; irq < IRQ_GPIO_POD(16) ; irq++) { irq_set_chip(irq, NULL); irq_set_handler(irq, NULL); set_irq_flags(irq, 0); } free_irq(resource_irq->start, cg_chip); dev_set_drvdata(&pdev->dev, NULL); return 0; }
static int bgpio_pdev_remove(struct platform_device *pdev) { struct gpio_chip *gc = platform_get_drvdata(pdev); gpiochip_remove(gc); return 0; }
static int cs75xx_gpio_remove(struct platform_device *pdev) { int i, j; gpio_dbgmsg("Function: %s\n", __func__); /* disable irq and deregister to gpiolib */ for (i = 0; i < GPIO_BANK_NUM; i++) { /* disable, unmask and clear all interrupts */ __raw_writel(0x0, cs75xx_gpio_base[i] + CS75XX_GPIO_IE); __raw_writel(~0x0, cs75xx_gpio_base[i] + CS75XX_GPIO_INT); for (j = GPIO_IRQ_BASE + i * GPIO_BANK_SIZE; j < GPIO_IRQ_BASE + (i + 1) * GPIO_BANK_SIZE; j++) { irq_set_chip(j, NULL); irq_set_handler(j, NULL); set_irq_flags(j, 0); } irq_set_chained_handler(cs75xx_irq_gpio[i], NULL); irq_set_handler_data(cs75xx_irq_gpio[i], NULL); } BUG_ON(gpiochip_remove(&cs75xx_gpio_chip)); for (i = 0; i < GPIO_BANK_NUM; i++) __raw_writel(0x0, cs75xx_global_base + CS75XX_GPIO_MUX_0 + i*4); // disable valid gpio pin return 0; }
static int sch_gpio_remove(struct platform_device *pdev) { struct sch_gpio *sch = platform_get_drvdata(pdev); gpiochip_remove(&sch->chip); return 0; }
static int palmas_gpio_remove(struct platform_device *pdev) { struct palmas_gpio *palmas_gpio = platform_get_drvdata(pdev); gpiochip_remove(&palmas_gpio->gpio_chip); return 0; }
static int sc16is7xx_remove(struct device *dev) { struct sc16is7xx_port *s = dev_get_drvdata(dev); int i, ret = 0; #ifdef CONFIG_GPIOLIB if (s->devtype->nr_gpio) { ret = gpiochip_remove(&s->gpio); if (ret) return ret; } #endif for (i = 0; i < s->uart.nr; i++) { cancel_work_sync(&s->p[i].tx_work); cancel_work_sync(&s->p[i].md_work); uart_remove_one_port(&s->uart, &s->p[i].port); sc16is7xx_power(&s->p[i].port, 0); } mutex_destroy(&s->mutex); uart_unregister_driver(&s->uart); if (!IS_ERR(s->clk)) clk_disable_unprepare(s->clk); return ret; }
static int __devexit max732x_remove(struct i2c_client *client) { struct max732x_platform_data *pdata = client->dev.platform_data; struct max732x_chip *chip = i2c_get_clientdata(client); int ret; if (pdata->teardown) { ret = pdata->teardown(client, chip->gpio_chip.base, chip->gpio_chip.ngpio, pdata->context); if (ret < 0) { dev_err(&client->dev, "%s failed, %d\n", "teardown", ret); return ret; } } ret = gpiochip_remove(&chip->gpio_chip); if (ret) { dev_err(&client->dev, "%s failed, %d\n", "gpiochip_remove()", ret); return ret; } max732x_irq_teardown(chip); /* unregister any dummy i2c_client */ if (chip->client_dummy) i2c_unregister_device(chip->client_dummy); kfree(chip); return 0; }
static void __exit amd_gpio_exit(void) { int err = gpiochip_remove(&gp.chip); WARN_ON(err); ioport_unmap(gp.pm); release_region(gp.pmbase + PMBASE_OFFSET, PMBASE_SIZE); }
static int pca953x_remove(struct i2c_client *client) { struct pca953x_platform_data *pdata = client->dev.platform_data; struct pca953x_chip *chip = i2c_get_clientdata(client); int ret = 0; if (pdata->teardown) { ret = pdata->teardown(client, chip->gpio_chip.base, chip->gpio_chip.ngpio, pdata->context); if (ret < 0) { dev_err(&client->dev, "%s failed, %d\n", "teardown", ret); return ret; } } ret = gpiochip_remove(&chip->gpio_chip); if (ret) { dev_err(&client->dev, "%s failed, %d\n", "gpiochip_remove()", ret); return ret; } kfree(chip); return 0; }
static int __devexit tc6393xb_remove(struct platform_device *dev) { struct tc6393xb_platform_data *tcpd = dev->dev.platform_data; struct tc6393xb *tc6393xb = platform_get_drvdata(dev); int ret; mfd_remove_devices(&dev->dev); if (tcpd->teardown) tcpd->teardown(dev); tc6393xb_detach_irq(dev); if (tc6393xb->gpio.base != -1) { ret = gpiochip_remove(&tc6393xb->gpio); if (ret) { dev_err(&dev->dev, "Can't remove gpio chip: %d\n", ret); return ret; } } ret = tcpd->disable(dev); clk_disable(tc6393xb->clk); iounmap(tc6393xb->scr); release_resource(&tc6393xb->rscr); platform_set_drvdata(dev, NULL); clk_put(tc6393xb->clk); kfree(tc6393xb); return ret; }
static int tc6393xb_remove(struct platform_device *dev) { struct tc6393xb_platform_data *tcpd = dev_get_platdata(&dev->dev); struct tc6393xb *tc6393xb = platform_get_drvdata(dev); int ret; mfd_remove_devices(&dev->dev); if (tcpd->teardown) tcpd->teardown(dev); tc6393xb_detach_irq(dev); if (tc6393xb->gpio.base != -1) gpiochip_remove(&tc6393xb->gpio); ret = tcpd->disable(dev); clk_disable(tc6393xb->clk); iounmap(tc6393xb->scr); release_resource(&tc6393xb->rscr); clk_put(tc6393xb->clk); kfree(tc6393xb); return ret; }
int bgpio_remove(struct bgpio_chip *bgc) { int err = gpiochip_remove(&bgc->gc); kfree(bgc); return err; }
static int pt_gpio_remove(struct platform_device *pdev) { struct pt_gpio_chip *pt_gpio = platform_get_drvdata(pdev); gpiochip_remove(&pt_gpio->gc); return 0; }
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 vx855gpio_remove(struct platform_device *pdev) { struct vx855_gpio *vg = platform_get_drvdata(pdev); gpiochip_remove(&vg->gpio); return 0; }
static void __exit it8761e_gpio_exit(void) { if (gpio_ba) { gpiochip_remove(&it8761e_gpio_chip); release_region(gpio_ba, GPIO_IOSIZE); gpio_ba = 0; } }
static int as3722_pinctrl_remove(struct platform_device *pdev) { struct as3722_pctrl_info *as_pci = platform_get_drvdata(pdev); gpiochip_remove(&as_pci->gpio_chip); pinctrl_unregister(as_pci->pctl); return 0; }
static int ttl_remove(struct platform_device *pdev) { struct ttl_module *mod = platform_get_drvdata(pdev); gpiochip_remove(&mod->gpio); return 0; }
static int pmic_mpp_remove(struct platform_device *pdev) { struct pmic_mpp_state *state = platform_get_drvdata(pdev); gpiochip_remove(&state->chip); pinctrl_unregister(state->ctrl); return 0; }