mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-22 02:20:40 +00:00
b05ddad009
GPIOLIB core: - provide interfaces allowing users to retrieve, manage and query the reference counted GPIO device instead of accessing the private gpio_chip structure - replace gpiochip_find() with gpio_device_find() - remove unused acpi_get_and_request_gpiod() - improve the ignore_interrupt functionality in GPIO ACPI - correct notifier return codes in gpiolib-of - unexport gpiod_set_transitory() as it's unused outside of core GPIO code - while there are still external users accessing struct gpio_chip, let's make gpiochip_get_desc() public so that they at least use the preferred helper - improve locking for lookup tables - annotate struct linereq with __counted_by - improve GPIOLIB docs - add an OF quirk for LED trigger sources Driver improvements: - convert all GPIO drivers with .remove() callbacks to using the new variant returning void instead of int - stop accessing the GPIOLIB private structures in gpio-mockup, i2c-mux-gpio, hte-tegra194, gpio-sim - use the recommended pattern for autofree variables in gpio-sim - add support for more models to gpio-loongson - use a notifier chain to notify other blocks about interrupts in gpio-eic-sprd instead of looking up GPIO devices on every interrupt - convert gpio-pca953x and gpio-fx6408 to using the maple tree regmap cache - don't include GPIOLIB internal headers in drivers which don't need them - move the ingenic NAND quirk into gpiolib-of - add an ignore interrupt quirk for Peaq C1010 - drop static GPIO base from gpio-omap, gpio-f7188x - use the preferred device_get_match_data() function in drivers that still don't - refactor gpio-pca953x: switch to using DEFINE_SIMPLE_DEV_PM_OPS(), use cleanup helpers, use dev_err_probe() where it makes sense, fully convert to using devres and some other minor tweaks DT bindings: - add support for a new model to gpio-vf610 and update existing properties - add support for more loongson models - add missing support for imx models that are used but undocumented - convert bindings for Intel IXP4xx to schema Minor stuff: - deprecate gpio-mockup in favor of gpio-sim - include missing headers here and there - stop using gpiochip_find() in OMAP1 board files - minor tweaks in gpio-vf610, gpio-hisi - remove unneeded 'extern' specifiers from headers -----BEGIN PGP SIGNATURE----- iQIzBAABCgAdFiEEFp3rbAvDxGAT0sefEacuoBRx13IFAmU7ixgACgkQEacuoBRx 13JwfxAA4CeZdXdUpx6EMUw+6ST4EWb5JanrPjNcQbyBxNFrHx+6yJJL4AOQJStQ WkG+Zi8Li9uV3wZQixBDs0WN8xVwJU+4QLSwwtNhEjl2x9MkVjghh4la6TqBrMj8 e/iJufTyKUgcm2P4MRTDXFarAin4doBQUPKWfCgL18VvlKxLXG0KMndUl3jAd/Rm YZLm4Z/iqWaxjfrm+E9LfWFmWS5T7t/g+7TYzMp2AHQ9dHFiwoodpiHTkdWH4dfL zxF8Ek2132Up0BYC1lQlwz1aoLIlHcr9xVOqOrIxZI/B5xRcUfoXnQQmCCfH2UYr wtfwKMI7IO2d5E+F7anFC67d9wm7tWacKEifw9lWUAD6xr6yv/13ZOU6aoWXj1Vq xOMe6gEeZSboF/XiqlmrpZYH+ljDp/mYWkGcOJrUg7WYUgvUCFWu6l6DmuUFMr7m ACtOUqwbTuWTXN28QtMOpjiQRqlAWyrY6PqhBCllhmcjsoVaZNgWEfriPlSOyoBg EBRBcURXLs7/h86nEsK/8BIsC0myHbpNiNpG5qaMjrrYJxMh4qS4MIG83MWAy1dZ 8ZtYrxx4XClyaYwYomsIkseLaSCrBTIoYws7wmyTjYfKC7P/t6/XXPS1suyMnf9I /n5tN8Rv1pDrnS3iQflHQVl9H5m4yezHOOBJUiWW+gs5MUr4vK0= =1QF8 -----END PGP SIGNATURE----- Merge tag 'gpio-updates-for-v6.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/brgl/linux Pull gpio updates from Bartosz Golaszewski: "We don't have any new drivers. The loongson driver is getting extended with support for new models. There's a big refactor of gpio-pca953x and many small improvements to others. The GPIO code in the kernel has acquired a lot of cruft over the years as well as many abusers of the API across the kernel tree. This release cycle we have started a major cleanup and improvement effort that will most likely span several releases. We have started by converting external users of struct gpio_chip to accessing the wrapper around it - struct gpio_device. This is because the latter is reference counted while the former is removed when the provider is unbound. We also removed several instances of drivers accessing private GPIOLIB structures and including the private header from drivers/gpio/. To that end you'll see several commits aimed at different subsystems (acked by relevant maintainers) as well as two merges from the x86/platform tree. We'll then rework the locking in GPIOLIB which currently uses a big spinlock for many different things and could use becoming more fine-grained, especially as it doesn't even get the locking right. We'll also use SRCU for protecting the gpio_chip pointer against in-kernel hot-unplug crashes similar to what we saw triggered from user-space and fixed with semaphores in gpiolib-cdev. The core GPIOLIB is still vulnerable to these use-cases. I'm just mentioning the plans here, this is not part of this PR. You'll see some new instances of using __free(). We've added a gpio_device_put cleanup helper similar to the put_device one introduced by Peter Zijlstra and used it according to the preferred pattern except where it didn't make sense. GPIOLIB core: - provide interfaces allowing users to retrieve, manage and query the reference counted GPIO device instead of accessing the private gpio_chip structure - replace gpiochip_find() with gpio_device_find() - remove unused acpi_get_and_request_gpiod() - improve the ignore_interrupt functionality in GPIO ACPI - correct notifier return codes in gpiolib-of - unexport gpiod_set_transitory() as it's unused outside of core GPIO code - while there are still external users accessing struct gpio_chip, let's make gpiochip_get_desc() public so that they at least use the preferred helper - improve locking for lookup tables - annotate struct linereq with __counted_by - improve GPIOLIB docs - add an OF quirk for LED trigger sources Driver improvements: - convert all GPIO drivers with .remove() callbacks to using the new variant returning void instead of int - stop accessing the GPIOLIB private structures in gpio-mockup, i2c-mux-gpio, hte-tegra194, gpio-sim - use the recommended pattern for autofree variables in gpio-sim - add support for more models to gpio-loongson - use a notifier chain to notify other blocks about interrupts in gpio-eic-sprd instead of looking up GPIO devices on every interrupt - convert gpio-pca953x and gpio-fx6408 to using the maple tree regmap cache - don't include GPIOLIB internal headers in drivers which don't need them - move the ingenic NAND quirk into gpiolib-of - add an ignore interrupt quirk for Peaq C1010 - drop static GPIO base from gpio-omap, gpio-f7188x - use the preferred device_get_match_data() function in drivers that still don't - refactor gpio-pca953x: switch to using DEFINE_SIMPLE_DEV_PM_OPS(), use cleanup helpers, use dev_err_probe() where it makes sense, fully convert to using devres and some other minor tweaks DT bindings: - add support for a new model to gpio-vf610 and update existing properties - add support for more loongson models - add missing support for imx models that are used but undocumented - convert bindings for Intel IXP4xx to schema Minor stuff: - deprecate gpio-mockup in favor of gpio-sim - include missing headers here and there - stop using gpiochip_find() in OMAP1 board files - minor tweaks in gpio-vf610, gpio-hisi - remove unneeded 'extern' specifiers from headers" * tag 'gpio-updates-for-v6.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/brgl/linux: (108 commits) hte: tegra194: add GPIOLIB dependency hte: tegra194: don't access struct gpio_chip gpiolib: provide gpio_device_get_base() i2c: mux: gpio: don't fiddle with GPIOLIB internals gpiolib: provide gpiod_to_gpio_device() gpiolib: provide gpio_device_to_device() gpio: hisi: Fix format specifier gpiolib: provide gpio_device_find_by_fwnode() gpio: acpi: remove acpi_get_and_request_gpiod() gpio: Use device_get_match_data() gpio: vf610: update comment for i.MX8ULP and i.MX93 legacy compatibles platform/x86: int3472: Switch to devm_get_gpiod() platform/x86: int3472: Stop using gpiod_toggle_active_low() platform/x86: int3472: Add new skl_int3472_gpiod_get_from_temp_lookup() helper platform/x86: int3472: Add new skl_int3472_fill_gpiod_lookup() helper gpio: vf610: simplify code by dropping data check gpio: vf610: add i.MX8ULP of_device_id entry dt-bindings: gpio: vf610: add i.MX95 compatible dt-bindings: gpio: vf610: correct i.MX8ULP and i.MX93 dt-bindings: gpio: vf610: update gpio-ranges ...
397 lines
9.6 KiB
C
397 lines
9.6 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Freescale vf610 GPIO support through PORT and GPIO
|
|
*
|
|
* Copyright (c) 2014 Toradex AG.
|
|
*
|
|
* Author: Stefan Agner <stefan@agner.ch>.
|
|
*/
|
|
#include <linux/bitops.h>
|
|
#include <linux/clk.h>
|
|
#include <linux/err.h>
|
|
#include <linux/gpio/driver.h>
|
|
#include <linux/init.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/io.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/irq.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_irq.h>
|
|
#include <linux/pinctrl/consumer.h>
|
|
|
|
#define VF610_GPIO_PER_PORT 32
|
|
|
|
struct fsl_gpio_soc_data {
|
|
/* SoCs has a Port Data Direction Register (PDDR) */
|
|
bool have_paddr;
|
|
bool have_dual_base;
|
|
};
|
|
|
|
struct vf610_gpio_port {
|
|
struct gpio_chip gc;
|
|
void __iomem *base;
|
|
void __iomem *gpio_base;
|
|
const struct fsl_gpio_soc_data *sdata;
|
|
u8 irqc[VF610_GPIO_PER_PORT];
|
|
struct clk *clk_port;
|
|
struct clk *clk_gpio;
|
|
int irq;
|
|
};
|
|
|
|
#define GPIO_PDOR 0x00
|
|
#define GPIO_PSOR 0x04
|
|
#define GPIO_PCOR 0x08
|
|
#define GPIO_PTOR 0x0c
|
|
#define GPIO_PDIR 0x10
|
|
#define GPIO_PDDR 0x14
|
|
|
|
#define PORT_PCR(n) ((n) * 0x4)
|
|
#define PORT_PCR_IRQC_OFFSET 16
|
|
|
|
#define PORT_ISFR 0xa0
|
|
#define PORT_DFER 0xc0
|
|
#define PORT_DFCR 0xc4
|
|
#define PORT_DFWR 0xc8
|
|
|
|
#define PORT_INT_OFF 0x0
|
|
#define PORT_INT_LOGIC_ZERO 0x8
|
|
#define PORT_INT_RISING_EDGE 0x9
|
|
#define PORT_INT_FALLING_EDGE 0xa
|
|
#define PORT_INT_EITHER_EDGE 0xb
|
|
#define PORT_INT_LOGIC_ONE 0xc
|
|
|
|
#define IMX8ULP_GPIO_BASE_OFF 0x40
|
|
#define IMX8ULP_BASE_OFF 0x80
|
|
|
|
static const struct fsl_gpio_soc_data vf610_data = {
|
|
.have_dual_base = true,
|
|
};
|
|
|
|
static const struct fsl_gpio_soc_data imx_data = {
|
|
.have_paddr = true,
|
|
.have_dual_base = true,
|
|
};
|
|
|
|
static const struct fsl_gpio_soc_data imx8ulp_data = {
|
|
.have_paddr = true,
|
|
};
|
|
|
|
static const struct of_device_id vf610_gpio_dt_ids[] = {
|
|
{ .compatible = "fsl,vf610-gpio", .data = &vf610_data },
|
|
{ .compatible = "fsl,imx7ulp-gpio", .data = &imx_data, },
|
|
{ .compatible = "fsl,imx8ulp-gpio", .data = &imx8ulp_data, },
|
|
{ /* sentinel */ }
|
|
};
|
|
|
|
static inline void vf610_gpio_writel(u32 val, void __iomem *reg)
|
|
{
|
|
writel_relaxed(val, reg);
|
|
}
|
|
|
|
static inline u32 vf610_gpio_readl(void __iomem *reg)
|
|
{
|
|
return readl_relaxed(reg);
|
|
}
|
|
|
|
static int vf610_gpio_get(struct gpio_chip *gc, unsigned int gpio)
|
|
{
|
|
struct vf610_gpio_port *port = gpiochip_get_data(gc);
|
|
unsigned long mask = BIT(gpio);
|
|
unsigned long offset = GPIO_PDIR;
|
|
|
|
if (port->sdata->have_paddr) {
|
|
mask &= vf610_gpio_readl(port->gpio_base + GPIO_PDDR);
|
|
if (mask)
|
|
offset = GPIO_PDOR;
|
|
}
|
|
|
|
return !!(vf610_gpio_readl(port->gpio_base + offset) & BIT(gpio));
|
|
}
|
|
|
|
static void vf610_gpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
|
|
{
|
|
struct vf610_gpio_port *port = gpiochip_get_data(gc);
|
|
unsigned long mask = BIT(gpio);
|
|
unsigned long offset = val ? GPIO_PSOR : GPIO_PCOR;
|
|
|
|
vf610_gpio_writel(mask, port->gpio_base + offset);
|
|
}
|
|
|
|
static int vf610_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
|
|
{
|
|
struct vf610_gpio_port *port = gpiochip_get_data(chip);
|
|
unsigned long mask = BIT(gpio);
|
|
u32 val;
|
|
|
|
if (port->sdata->have_paddr) {
|
|
val = vf610_gpio_readl(port->gpio_base + GPIO_PDDR);
|
|
val &= ~mask;
|
|
vf610_gpio_writel(val, port->gpio_base + GPIO_PDDR);
|
|
}
|
|
|
|
return pinctrl_gpio_direction_input(chip->base + gpio);
|
|
}
|
|
|
|
static int vf610_gpio_direction_output(struct gpio_chip *chip, unsigned gpio,
|
|
int value)
|
|
{
|
|
struct vf610_gpio_port *port = gpiochip_get_data(chip);
|
|
unsigned long mask = BIT(gpio);
|
|
u32 val;
|
|
|
|
vf610_gpio_set(chip, gpio, value);
|
|
|
|
if (port->sdata->have_paddr) {
|
|
val = vf610_gpio_readl(port->gpio_base + GPIO_PDDR);
|
|
val |= mask;
|
|
vf610_gpio_writel(val, port->gpio_base + GPIO_PDDR);
|
|
}
|
|
|
|
return pinctrl_gpio_direction_output(chip->base + gpio);
|
|
}
|
|
|
|
static void vf610_gpio_irq_handler(struct irq_desc *desc)
|
|
{
|
|
struct vf610_gpio_port *port =
|
|
gpiochip_get_data(irq_desc_get_handler_data(desc));
|
|
struct irq_chip *chip = irq_desc_get_chip(desc);
|
|
int pin;
|
|
unsigned long irq_isfr;
|
|
|
|
chained_irq_enter(chip, desc);
|
|
|
|
irq_isfr = vf610_gpio_readl(port->base + PORT_ISFR);
|
|
|
|
for_each_set_bit(pin, &irq_isfr, VF610_GPIO_PER_PORT) {
|
|
vf610_gpio_writel(BIT(pin), port->base + PORT_ISFR);
|
|
|
|
generic_handle_domain_irq(port->gc.irq.domain, pin);
|
|
}
|
|
|
|
chained_irq_exit(chip, desc);
|
|
}
|
|
|
|
static void vf610_gpio_irq_ack(struct irq_data *d)
|
|
{
|
|
struct vf610_gpio_port *port =
|
|
gpiochip_get_data(irq_data_get_irq_chip_data(d));
|
|
int gpio = d->hwirq;
|
|
|
|
vf610_gpio_writel(BIT(gpio), port->base + PORT_ISFR);
|
|
}
|
|
|
|
static int vf610_gpio_irq_set_type(struct irq_data *d, u32 type)
|
|
{
|
|
struct vf610_gpio_port *port =
|
|
gpiochip_get_data(irq_data_get_irq_chip_data(d));
|
|
u8 irqc;
|
|
|
|
switch (type) {
|
|
case IRQ_TYPE_EDGE_RISING:
|
|
irqc = PORT_INT_RISING_EDGE;
|
|
break;
|
|
case IRQ_TYPE_EDGE_FALLING:
|
|
irqc = PORT_INT_FALLING_EDGE;
|
|
break;
|
|
case IRQ_TYPE_EDGE_BOTH:
|
|
irqc = PORT_INT_EITHER_EDGE;
|
|
break;
|
|
case IRQ_TYPE_LEVEL_LOW:
|
|
irqc = PORT_INT_LOGIC_ZERO;
|
|
break;
|
|
case IRQ_TYPE_LEVEL_HIGH:
|
|
irqc = PORT_INT_LOGIC_ONE;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
port->irqc[d->hwirq] = irqc;
|
|
|
|
if (type & IRQ_TYPE_LEVEL_MASK)
|
|
irq_set_handler_locked(d, handle_level_irq);
|
|
else
|
|
irq_set_handler_locked(d, handle_edge_irq);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void vf610_gpio_irq_mask(struct irq_data *d)
|
|
{
|
|
struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
|
|
struct vf610_gpio_port *port = gpiochip_get_data(gc);
|
|
irq_hw_number_t gpio_num = irqd_to_hwirq(d);
|
|
void __iomem *pcr_base = port->base + PORT_PCR(gpio_num);
|
|
|
|
vf610_gpio_writel(0, pcr_base);
|
|
gpiochip_disable_irq(gc, gpio_num);
|
|
}
|
|
|
|
static void vf610_gpio_irq_unmask(struct irq_data *d)
|
|
{
|
|
struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
|
|
struct vf610_gpio_port *port = gpiochip_get_data(gc);
|
|
irq_hw_number_t gpio_num = irqd_to_hwirq(d);
|
|
void __iomem *pcr_base = port->base + PORT_PCR(gpio_num);
|
|
|
|
gpiochip_enable_irq(gc, gpio_num);
|
|
vf610_gpio_writel(port->irqc[gpio_num] << PORT_PCR_IRQC_OFFSET,
|
|
pcr_base);
|
|
}
|
|
|
|
static int vf610_gpio_irq_set_wake(struct irq_data *d, u32 enable)
|
|
{
|
|
struct vf610_gpio_port *port =
|
|
gpiochip_get_data(irq_data_get_irq_chip_data(d));
|
|
|
|
if (enable)
|
|
enable_irq_wake(port->irq);
|
|
else
|
|
disable_irq_wake(port->irq);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct irq_chip vf610_irqchip = {
|
|
.name = "gpio-vf610",
|
|
.irq_ack = vf610_gpio_irq_ack,
|
|
.irq_mask = vf610_gpio_irq_mask,
|
|
.irq_unmask = vf610_gpio_irq_unmask,
|
|
.irq_set_type = vf610_gpio_irq_set_type,
|
|
.irq_set_wake = vf610_gpio_irq_set_wake,
|
|
.flags = IRQCHIP_IMMUTABLE | IRQCHIP_MASK_ON_SUSPEND
|
|
| IRQCHIP_ENABLE_WAKEUP_ON_SUSPEND,
|
|
GPIOCHIP_IRQ_RESOURCE_HELPERS,
|
|
};
|
|
|
|
static void vf610_gpio_disable_clk(void *data)
|
|
{
|
|
clk_disable_unprepare(data);
|
|
}
|
|
|
|
static int vf610_gpio_probe(struct platform_device *pdev)
|
|
{
|
|
struct device *dev = &pdev->dev;
|
|
struct vf610_gpio_port *port;
|
|
struct gpio_chip *gc;
|
|
struct gpio_irq_chip *girq;
|
|
int i;
|
|
int ret;
|
|
bool dual_base;
|
|
|
|
port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL);
|
|
if (!port)
|
|
return -ENOMEM;
|
|
|
|
port->sdata = of_device_get_match_data(dev);
|
|
|
|
dual_base = port->sdata->have_dual_base;
|
|
|
|
/*
|
|
* Handle legacy compatible combinations which used two reg values
|
|
* for the i.MX8ULP and i.MX93.
|
|
*/
|
|
if (device_is_compatible(dev, "fsl,imx7ulp-gpio") &&
|
|
(device_is_compatible(dev, "fsl,imx93-gpio") ||
|
|
(device_is_compatible(dev, "fsl,imx8ulp-gpio"))))
|
|
dual_base = true;
|
|
|
|
if (dual_base) {
|
|
port->base = devm_platform_ioremap_resource(pdev, 0);
|
|
if (IS_ERR(port->base))
|
|
return PTR_ERR(port->base);
|
|
|
|
port->gpio_base = devm_platform_ioremap_resource(pdev, 1);
|
|
if (IS_ERR(port->gpio_base))
|
|
return PTR_ERR(port->gpio_base);
|
|
} else {
|
|
port->base = devm_platform_ioremap_resource(pdev, 0);
|
|
if (IS_ERR(port->base))
|
|
return PTR_ERR(port->base);
|
|
|
|
port->gpio_base = port->base + IMX8ULP_GPIO_BASE_OFF;
|
|
port->base = port->base + IMX8ULP_BASE_OFF;
|
|
}
|
|
|
|
port->irq = platform_get_irq(pdev, 0);
|
|
if (port->irq < 0)
|
|
return port->irq;
|
|
|
|
port->clk_port = devm_clk_get(dev, "port");
|
|
ret = PTR_ERR_OR_ZERO(port->clk_port);
|
|
if (!ret) {
|
|
ret = clk_prepare_enable(port->clk_port);
|
|
if (ret)
|
|
return ret;
|
|
ret = devm_add_action_or_reset(dev, vf610_gpio_disable_clk,
|
|
port->clk_port);
|
|
if (ret)
|
|
return ret;
|
|
} else if (ret == -EPROBE_DEFER) {
|
|
/*
|
|
* Percolate deferrals, for anything else,
|
|
* just live without the clocking.
|
|
*/
|
|
return ret;
|
|
}
|
|
|
|
port->clk_gpio = devm_clk_get(dev, "gpio");
|
|
ret = PTR_ERR_OR_ZERO(port->clk_gpio);
|
|
if (!ret) {
|
|
ret = clk_prepare_enable(port->clk_gpio);
|
|
if (ret)
|
|
return ret;
|
|
ret = devm_add_action_or_reset(dev, vf610_gpio_disable_clk,
|
|
port->clk_gpio);
|
|
if (ret)
|
|
return ret;
|
|
} else if (ret == -EPROBE_DEFER) {
|
|
return ret;
|
|
}
|
|
|
|
gc = &port->gc;
|
|
gc->parent = dev;
|
|
gc->label = dev_name(dev);
|
|
gc->ngpio = VF610_GPIO_PER_PORT;
|
|
gc->base = -1;
|
|
|
|
gc->request = gpiochip_generic_request;
|
|
gc->free = gpiochip_generic_free;
|
|
gc->direction_input = vf610_gpio_direction_input;
|
|
gc->get = vf610_gpio_get;
|
|
gc->direction_output = vf610_gpio_direction_output;
|
|
gc->set = vf610_gpio_set;
|
|
|
|
/* Mask all GPIO interrupts */
|
|
for (i = 0; i < gc->ngpio; i++)
|
|
vf610_gpio_writel(0, port->base + PORT_PCR(i));
|
|
|
|
/* Clear the interrupt status register for all GPIO's */
|
|
vf610_gpio_writel(~0, port->base + PORT_ISFR);
|
|
|
|
girq = &gc->irq;
|
|
gpio_irq_chip_set_chip(girq, &vf610_irqchip);
|
|
girq->parent_handler = vf610_gpio_irq_handler;
|
|
girq->num_parents = 1;
|
|
girq->parents = devm_kcalloc(&pdev->dev, 1,
|
|
sizeof(*girq->parents),
|
|
GFP_KERNEL);
|
|
if (!girq->parents)
|
|
return -ENOMEM;
|
|
girq->parents[0] = port->irq;
|
|
girq->default_type = IRQ_TYPE_NONE;
|
|
girq->handler = handle_edge_irq;
|
|
|
|
return devm_gpiochip_add_data(dev, gc, port);
|
|
}
|
|
|
|
static struct platform_driver vf610_gpio_driver = {
|
|
.driver = {
|
|
.name = "gpio-vf610",
|
|
.of_match_table = vf610_gpio_dt_ids,
|
|
},
|
|
.probe = vf610_gpio_probe,
|
|
};
|
|
|
|
builtin_platform_driver(vf610_gpio_driver);
|