staging: greybus: gpio: switch GPIO portions to use GPIOLIB_IRQCHIP

config GREYBUS_GPIO

	tristate "Greybus GPIO Bridged PHY driver"

	depends on GPIOLIB

	select GPIOLIB_IRQCHIP

	---help---

	  Select this option if you have a device that follows the

	  Greybus GPIO Bridged PHY Class specification.

* Convert all uses of the old GPIO API from <linux/gpio.h> to the

  GPIO descriptor API in <linux/gpio/consumer.h> and look up GPIO

  lines from device tree or ACPI.

* Convert the GPIO driver to use the GPIO irqchip library

  GPIOLIB_IRQCHIP instead of reimplementing the same.

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/slab.h>

#include <linux/gpio.h>

#include <linux/irq.h>

#include <linux/irqdomain.h>

#include <linux/gpio/driver.h>

#include <linux/mutex.h>

#include "greybus.h"

	struct gpio_chip	chip;

	struct irq_chip		irqc;

	struct irq_chip		*irqchip;

	struct irq_domain	*irqdomain;

	unsigned int		irq_base;

	irq_flow_handler_t	irq_handler;

	unsigned int		irq_default_type;

	struct mutex		irq_lock;

};

#define gpio_chip_to_gb_gpio_controller(chip) \

		return -EINVAL;

	}

	irq = irq_find_mapping(ggc->irqdomain, event->which);

	irq = irq_find_mapping(ggc->chip.irq.domain, event->which);

	if (!irq) {

		dev_err(dev, "failed to find IRQ\n");

		return -EINVAL;

	return ret;

}

/**

 * gb_gpio_irq_map() - maps an IRQ into a GB gpio irqchip

 * @d: the irqdomain used by this irqchip

 * @irq: the global irq number used by this GB gpio irqchip irq

 * @hwirq: the local IRQ/GPIO line offset on this GB gpio

 *

 * This function will set up the mapping for a certain IRQ line on a

 * GB gpio by assigning the GB gpio as chip data, and using the irqchip

 * stored inside the GB gpio.

 */

static int gb_gpio_irq_map(struct irq_domain *domain, unsigned int irq,

			   irq_hw_number_t hwirq)

{

	struct gpio_chip *chip = domain->host_data;

	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);

	irq_set_chip_data(irq, ggc);

	irq_set_chip_and_handler(irq, ggc->irqchip, ggc->irq_handler);

	irq_set_noprobe(irq);

	/*

	 * No set-up of the hardware will happen if IRQ_TYPE_NONE

	 * is passed as default type.

	 */

	if (ggc->irq_default_type != IRQ_TYPE_NONE)

		irq_set_irq_type(irq, ggc->irq_default_type);

	return 0;

}

static void gb_gpio_irq_unmap(struct irq_domain *d, unsigned int irq)

{

	irq_set_chip_and_handler(irq, NULL, NULL);

	irq_set_chip_data(irq, NULL);

}

static const struct irq_domain_ops gb_gpio_domain_ops = {

	.map	= gb_gpio_irq_map,

	.unmap	= gb_gpio_irq_unmap,

};

/**

 * gb_gpio_irqchip_remove() - removes an irqchip added to a gb_gpio_controller

 * @ggc: the gb_gpio_controller to remove the irqchip from

 *

 * This is called only from gb_gpio_remove()

 */

static void gb_gpio_irqchip_remove(struct gb_gpio_controller *ggc)

{

	unsigned int offset;

	/* Remove all IRQ mappings and delete the domain */

	if (ggc->irqdomain) {

		for (offset = 0; offset < (ggc->line_max + 1); offset++)

			irq_dispose_mapping(irq_find_mapping(ggc->irqdomain,

							     offset));

		irq_domain_remove(ggc->irqdomain);

	}

	if (ggc->irqchip)

		ggc->irqchip = NULL;

}

/**

 * gb_gpio_irqchip_add() - adds an irqchip to a gpio chip

 * @chip: the gpio chip to add the irqchip to

 * @irqchip: the irqchip to add to the adapter

 * @first_irq: if not dynamically assigned, the base (first) IRQ to

 * allocate gpio irqs from

 * @handler: the irq handler to use (often a predefined irq core function)

 * @type: the default type for IRQs on this irqchip, pass IRQ_TYPE_NONE

 * to have the core avoid setting up any default type in the hardware.

 *

 * This function closely associates a certain irqchip with a certain

 * gpio chip, providing an irq domain to translate the local IRQs to

 * global irqs, and making sure that the gpio chip

 * is passed as chip data to all related functions. Driver callbacks

 * need to use container_of() to get their local state containers back

 * from the gpio chip passed as chip data. An irqdomain will be stored

 * in the gpio chip that shall be used by the driver to handle IRQ number

 * translation. The gpio chip will need to be initialized and registered

 * before calling this function.

 */

static int gb_gpio_irqchip_add(struct gpio_chip *chip,

			       struct irq_chip *irqchip,

			       unsigned int first_irq,

			       irq_flow_handler_t handler,

			       unsigned int type)

{

	struct gb_gpio_controller *ggc;

	unsigned int offset;

	unsigned int irq_base;

	if (!chip || !irqchip)

		return -EINVAL;

	ggc = gpio_chip_to_gb_gpio_controller(chip);

	ggc->irqchip = irqchip;

	ggc->irq_handler = handler;

	ggc->irq_default_type = type;

	ggc->irqdomain = irq_domain_add_simple(NULL,

					       ggc->line_max + 1, first_irq,

					       &gb_gpio_domain_ops, chip);

	if (!ggc->irqdomain) {

		ggc->irqchip = NULL;

		return -EINVAL;

	}

	/*

	 * Prepare the mapping since the irqchip shall be orthogonal to

	 * any gpio calls. If the first_irq was zero, this is

	 * necessary to allocate descriptors for all IRQs.

	 */

	for (offset = 0; offset < (ggc->line_max + 1); offset++) {

		irq_base = irq_create_mapping(ggc->irqdomain, offset);

		if (offset == 0)

			ggc->irq_base = irq_base;

	}

	return 0;

}

static int gb_gpio_to_irq(struct gpio_chip *chip, unsigned int offset)

{

	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);

	return irq_find_mapping(ggc->irqdomain, offset);

}

static int gb_gpio_probe(struct gbphy_device *gbphy_dev,

			 const struct gbphy_device_id *id)

{

	gpio->get = gb_gpio_get;

	gpio->set = gb_gpio_set;

	gpio->set_config = gb_gpio_set_config;

	gpio->to_irq = gb_gpio_to_irq;

	gpio->base = -1;		/* Allocate base dynamically */

	gpio->ngpio = ggc->line_max + 1;

	gpio->can_sleep = true;

	if (ret)

		goto exit_line_free;

	ret = gb_gpio_irqchip_add(gpio, irqc, 0,

				  handle_level_irq, IRQ_TYPE_NONE);

	ret = gpiochip_add(gpio);

	if (ret) {

		dev_err(&gbphy_dev->dev, "failed to add irq chip: %d\n", ret);

		dev_err(&gbphy_dev->dev, "failed to add gpio chip: %d\n", ret);

		goto exit_line_free;

	}

	ret = gpiochip_add(gpio);

	ret = gpiochip_irqchip_add(gpio, irqc, 0, handle_level_irq,

				   IRQ_TYPE_NONE);

	if (ret) {

		dev_err(&gbphy_dev->dev, "failed to add gpio chip: %d\n", ret);

		goto exit_gpio_irqchip_remove;

		dev_err(&gbphy_dev->dev, "failed to add irq chip: %d\n", ret);

		goto exit_gpiochip_remove;

	}

	gbphy_runtime_put_autosuspend(gbphy_dev);

	return 0;

exit_gpio_irqchip_remove:

	gb_gpio_irqchip_remove(ggc);

exit_gpiochip_remove:

	gpiochip_remove(gpio);

exit_line_free:

	kfree(ggc->lines);

exit_connection_disable:

	gb_connection_disable_rx(connection);

	gpiochip_remove(&ggc->chip);

	gb_gpio_irqchip_remove(ggc);

	gb_connection_disable(connection);

	gb_connection_destroy(connection);

	kfree(ggc->lines);