Пример #1
0
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;
}
Пример #2
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;
}
Пример #3
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;
}
Пример #4
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;
}
Пример #6
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;
}
Пример #7
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;
}
Пример #8
0
void pio2_gpio_exit(struct pio2_card *card)
{
	const char *label = card->gc.label;

	gpiochip_remove(&(card->gc));
	kfree(label);
}
Пример #9
0
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;
}
Пример #10
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;
}
Пример #11
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;
}
Пример #12
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;
}
Пример #13
0
static int bgpio_pdev_remove(struct platform_device *pdev)
{
	struct gpio_chip *gc = platform_get_drvdata(pdev);

	gpiochip_remove(gc);
	return 0;
}
Пример #14
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;
}
Пример #15
0
static int sch_gpio_remove(struct platform_device *pdev)
{
	struct sch_gpio *sch = platform_get_drvdata(pdev);

	gpiochip_remove(&sch->chip);
	return 0;
}
Пример #16
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;
}
Пример #17
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;
}
Пример #18
0
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;
}
Пример #19
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);
}
Пример #20
0
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;
}
Пример #21
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;
}
Пример #22
0
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;
}
Пример #24
0
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;
}
Пример #25
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;
}
Пример #26
0
static int vx855gpio_remove(struct platform_device *pdev)
{
	struct vx855_gpio *vg = platform_get_drvdata(pdev);

	gpiochip_remove(&vg->gpio);

	return 0;
}
Пример #27
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;
	}
}
Пример #28
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;
}
Пример #29
0
static int ttl_remove(struct platform_device *pdev)
{
	struct ttl_module *mod = platform_get_drvdata(pdev);

	gpiochip_remove(&mod->gpio);

	return 0;
}
Пример #30
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;
}