gpio: davinci: add OF support

Davinci GPIO controller bindings

Required Properties:

- compatible: should be "ti,dm6441-gpio"

- reg: Physical base address of the controller and the size of memory mapped

       registers.

- gpio-controller : Marks the device node as a gpio controller.

- interrupt-parent: phandle of the parent interrupt controller.

- interrupts: Array of GPIO interrupt number. Only banked or unbanked IRQs are

	      supported at a time.

- ti,ngpio: The number of GPIO pins supported.

- ti,davinci-gpio-unbanked: The number of GPIOs that have an individual interrupt

		             line to processor.

The GPIO controller also acts as an interrupt controller. It uses the default

two cells specifier as described in Documentation/devicetree/bindings/

interrupt-controller/interrupts.txt.

Example:

gpio: gpio@1e26000 {

	compatible = "ti,dm6441-gpio";

	gpio-controller;

	reg = <0x226000 0x1000>;

	interrupt-parent = <&intc>;

	interrupts = <42 IRQ_TYPE_EDGE_BOTH 43 IRQ_TYPE_EDGE_BOTH

		44 IRQ_TYPE_EDGE_BOTH 45 IRQ_TYPE_EDGE_BOTH

		46 IRQ_TYPE_EDGE_BOTH 47 IRQ_TYPE_EDGE_BOTH

		48 IRQ_TYPE_EDGE_BOTH 49 IRQ_TYPE_EDGE_BOTH

		50 IRQ_TYPE_EDGE_BOTH>;

	ti,ngpio = <144>;

	ti,davinci-gpio-unbanked = <0>;

	interrupt-controller;

	#interrupt-cells = <2>;

};

#include <linux/io.h>

#include <linux/irq.h>

#include <linux/irqdomain.h>

#include <linux/module.h>

#include <linux/of.h>

#include <linux/of_device.h>

#include <linux/platform_device.h>

#include <linux/platform_data/gpio-davinci.h>

	writel_relaxed((1 << offset), value ? &g->set_data : &g->clr_data);

}

static struct davinci_gpio_platform_data *

davinci_gpio_get_pdata(struct platform_device *pdev)

{

	struct device_node *dn = pdev->dev.of_node;

	struct davinci_gpio_platform_data *pdata;

	int ret;

	u32 val;

	if (!IS_ENABLED(CONFIG_OF) || !pdev->dev.of_node)

		return pdev->dev.platform_data;

	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);

	if (!pdata)

		return NULL;

	ret = of_property_read_u32(dn, "ti,ngpio", &val);

	if (ret)

		goto of_err;

	pdata->ngpio = val;

	ret = of_property_read_u32(dn, "ti,davinci-gpio-unbanked", &val);

	if (ret)

		goto of_err;

	pdata->gpio_unbanked = val;

	return pdata;

of_err:

	dev_err(&pdev->dev, "Populating pdata from DT failed: err %d\n", ret);

	return NULL;

}

static int davinci_gpio_probe(struct platform_device *pdev)

{

	int i, base;

	struct device *dev = &pdev->dev;

	struct resource *res;

	pdata = dev->platform_data;

	pdata = davinci_gpio_get_pdata(pdev);

	if (!pdata) {

		dev_err(dev, "No platform data found\n");

		return -EINVAL;

	}

	dev->platform_data = pdata;

	/*

	 * The gpio banks conceptually expose a segmented bitmap,

	 * and "ngpio" is one more than the largest zero-based

		if (chips[i].chip.ngpio > 32)

			chips[i].chip.ngpio = 32;

#ifdef CONFIG_OF_GPIO

		chips[i].chip.of_node = dev->of_node;

#endif

		spin_lock_init(&chips[i].lock);

		regs = gpio2regs(base);

	return 0;

}

#if IS_ENABLED(CONFIG_OF)

static const struct of_device_id davinci_gpio_ids[] = {

	{ .compatible = "ti,dm6441-gpio", },

	{ /* sentinel */ },

};

MODULE_DEVICE_TABLE(of, davinci_gpio_ids);

#endif

static struct platform_driver davinci_gpio_driver = {

	.probe		= davinci_gpio_probe,

	.driver		= {

		.name		= "davinci_gpio",

		.owner		= THIS_MODULE,

		.of_match_table	= of_match_ptr(davinci_gpio_ids),

	},

};