* [PATCH 0/3] gpio: Add support for Andes ATCGPIO100 GPIO controller
@ 2026-11-16 4:09 CL Wang
2026-11-16 4:09 ` [PATCH 1/3] dt-bindings: gpio: Add support for " CL Wang
` (2 more replies)
0 siblings, 3 replies; 4+ messages in thread
From: CL Wang @ 2026-11-16 4:09 UTC (permalink / raw)
To: Linus Walleij, Bartosz Golaszewski, Rob Herring,
Krzysztof Kozlowski, Conor Dooley
Cc: CL Wang, linux-gpio, devicetree, linux-kernel, tim609
This series adds support for the Andes ATCGPIO100 GPIO controller, an
IP integrated in the Andes AE350 platform and in SoCs such as Qilai.
The controller provides up to 32 lines with optional pull, interrupt
and debounce features, all reported by its configuration register.
The driver builds the data path on the generic MMIO GPIO library and
adds:
- Pull-up and pull-down bias
- Edge (rising, falling, both) and level (high, low) interrupts
- Hardware input debounce, clocked from pclk or an optional extclk
- Wakeup through the parent interrupt
- System suspend and resume
CL Wang (3):
dt-bindings: gpio: Add support for ATCGPIO100 GPIO controller
gpio: atcgpio100: Add ATCGPIO100 GPIO driver
MAINTAINERS: Add entry for Andes ATCGPIO100 GPIO
.../bindings/gpio/andestech,ae350-gpio.yaml | 92 +++
MAINTAINERS | 6 +
drivers/gpio/Kconfig | 16 +
drivers/gpio/Makefile | 1 +
drivers/gpio/gpio-atcgpio100.c | 641 ++++++++++++++++++
5 files changed, 756 insertions(+)
create mode 100644 Documentation/devicetree/bindings/gpio/andestech,ae350-gpio.yaml
create mode 100644 drivers/gpio/gpio-atcgpio100.c
base-commit: 7475ea8b58616b33c04afb976cf0fbaad9dd63fb
--
2.34.1
^ permalink raw reply [flat|nested] 4+ messages in thread
* [PATCH 1/3] dt-bindings: gpio: Add support for ATCGPIO100 GPIO controller
2026-11-16 4:09 [PATCH 0/3] gpio: Add support for Andes ATCGPIO100 GPIO controller CL Wang
@ 2026-11-16 4:09 ` CL Wang
2026-11-16 4:09 ` [PATCH 2/3] gpio: atcgpio100: Add ATCGPIO100 GPIO driver CL Wang
2026-11-16 4:09 ` [PATCH 3/3] MAINTAINERS: Add entry for Andes ATCGPIO100 GPIO CL Wang
2 siblings, 0 replies; 4+ messages in thread
From: CL Wang @ 2026-11-16 4:09 UTC (permalink / raw)
To: Linus Walleij, Bartosz Golaszewski, Rob Herring,
Krzysztof Kozlowski, Conor Dooley
Cc: CL Wang, linux-gpio, devicetree, linux-kernel, tim609
Document devicetree bindings for the Andes ATCGPIO100 GPIO controller.
ATCGPIO100 is the name of the IP, which is integrated in the Andes AE350
platform and in SoCs such as Qilai. As in the ATCSPI200 SPI controller
binding, the compatibles follow the platform and SoC rather than the IP
name: andestech,ae350-gpio is the fallback, and an SoC that integrates
the IP adds its own compatible, such as andestech,qilai-gpio, in front
of it. Drivers can then match on the fallback and still add SoC-specific
handling later.
The controller has up to 32 lines, and ngpios gives the number of lines
implemented. The debounce logic can run from either of two clocks: pclk,
the APB bus clock, which is required, or extclk, an optional external
clock that allows longer debounce periods. The interrupt is optional, as
the controller also works as a plain GPIO controller without it.
Signed-off-by: CL Wang <cl634@andestech.com>
---
.../bindings/gpio/andestech,ae350-gpio.yaml | 92 +++++++++++++++++++
1 file changed, 92 insertions(+)
create mode 100644 Documentation/devicetree/bindings/gpio/andestech,ae350-gpio.yaml
diff --git a/Documentation/devicetree/bindings/gpio/andestech,ae350-gpio.yaml b/Documentation/devicetree/bindings/gpio/andestech,ae350-gpio.yaml
new file mode 100644
index 000000000000..01badd2a1342
--- /dev/null
+++ b/Documentation/devicetree/bindings/gpio/andestech,ae350-gpio.yaml
@@ -0,0 +1,92 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/gpio/andestech,ae350-gpio.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: Andes ATCGPIO100 GPIO controller on AE350 platform
+
+maintainers:
+ - CL Wang <cl634@andestech.com>
+
+properties:
+ compatible:
+ oneOf:
+ - items:
+ - enum:
+ - andestech,qilai-gpio
+ - const: andestech,ae350-gpio
+ - const: andestech,ae350-gpio
+
+ reg:
+ maxItems: 1
+
+ interrupts:
+ maxItems: 1
+
+ interrupt-controller: true
+
+ "#interrupt-cells":
+ const: 2
+
+ gpio-controller: true
+
+ "#gpio-cells":
+ const: 2
+
+ ngpios:
+ minimum: 1
+ maximum: 32
+
+ gpio-line-names:
+ minItems: 1
+ maxItems: 32
+
+ clocks:
+ minItems: 1
+ items:
+ - description: APB bus clock
+ - description: External clock for debounce
+
+ clock-names:
+ minItems: 1
+ items:
+ - const: pclk
+ - const: extclk
+
+patternProperties:
+ "^.+-hog(-[0-9]+)?$":
+ type: object
+ required:
+ - gpio-hog
+
+required:
+ - compatible
+ - reg
+ - gpio-controller
+ - "#gpio-cells"
+ - clocks
+ - clock-names
+
+additionalProperties: false
+
+dependencies:
+ interrupt-controller: [ interrupts, "#interrupt-cells" ]
+
+examples:
+ - |
+ #include <dt-bindings/interrupt-controller/irq.h>
+
+ gpio@f0700000 {
+ compatible = "andestech,ae350-gpio";
+ reg = <0xf0700000 0x100>;
+ interrupts = <7 IRQ_TYPE_LEVEL_HIGH>;
+ interrupt-parent = <&plic>;
+ interrupt-controller;
+ #interrupt-cells = <2>;
+ gpio-controller;
+ #gpio-cells = <2>;
+ ngpios = <32>;
+ clocks = <&pclk>, <&extclk>;
+ clock-names = "pclk", "extclk";
+ };
--
2.34.1
^ permalink raw reply related [flat|nested] 4+ messages in thread
* [PATCH 2/3] gpio: atcgpio100: Add ATCGPIO100 GPIO driver
2026-11-16 4:09 [PATCH 0/3] gpio: Add support for Andes ATCGPIO100 GPIO controller CL Wang
2026-11-16 4:09 ` [PATCH 1/3] dt-bindings: gpio: Add support for " CL Wang
@ 2026-11-16 4:09 ` CL Wang
2026-11-16 4:09 ` [PATCH 3/3] MAINTAINERS: Add entry for Andes ATCGPIO100 GPIO CL Wang
2 siblings, 0 replies; 4+ messages in thread
From: CL Wang @ 2026-11-16 4:09 UTC (permalink / raw)
To: Linus Walleij, Bartosz Golaszewski, Rob Herring,
Krzysztof Kozlowski, Conor Dooley
Cc: CL Wang, linux-gpio, devicetree, linux-kernel, tim609
Add a driver for the Andes ATCGPIO100 GPIO controller, found on
AndesCore-based platforms such as AE350.
The controller provides up to 32 lines. The data path is built on the
generic MMIO GPIO library (gpio-mmio), and the number of lines and the
optional pull, interrupt and debounce features are read from the
configuration register at probe time.
The driver supports:
- Input and output, reading the output latch back for output lines
- Pull-up and pull-down bias
- Edge (rising, falling, both) and level (high, low) interrupts
- Hardware input debounce with a period shared by all lines
- Wakeup through the parent interrupt for lines that their consumers
mark as wakeup sources
- System suspend and resume
Signed-off-by: CL Wang <cl634@andestech.com>
---
drivers/gpio/Kconfig | 16 +
drivers/gpio/Makefile | 1 +
drivers/gpio/gpio-atcgpio100.c | 641 +++++++++++++++++++++++++++++++++
3 files changed, 658 insertions(+)
create mode 100644 drivers/gpio/gpio-atcgpio100.c
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 55e4280029d8..ad768976ff6c 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -194,6 +194,22 @@ config GPIO_ASPEED_SGPIO
help
Say Y here to support Aspeed AST2500 SGPIO functionality.
+config GPIO_ATCGPIO100
+ tristate "Andes ATCGPIO100 GPIO support"
+ depends on ARCH_ANDES || COMPILE_TEST
+ select GPIOLIB_IRQCHIP
+ select GPIO_GENERIC
+ help
+ Say Y or M here to build support for the Andes ATCGPIO100 GPIO
+ controller.
+
+ This IP block provides up to 32 general-purpose I/O pins with
+ configurable direction, pull-up and pull-down bias, edge and level
+ triggered interrupts, hardware input debounce and wakeup support.
+
+ To compile this driver as a module, choose M here: the module
+ will be called gpio-atcgpio100.
+
config GPIO_ATH79
tristate "Atheros AR71XX/AR724X/AR913X GPIO support"
default y if ATH79
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 88f748846e60..5a0abff4c91b 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -40,6 +40,7 @@ obj-$(CONFIG_GPIO_AMDPT) += gpio-amdpt.o
obj-$(CONFIG_GPIO_ARIZONA) += gpio-arizona.o
obj-$(CONFIG_GPIO_ASPEED) += gpio-aspeed.o
obj-$(CONFIG_GPIO_ASPEED_SGPIO) += gpio-aspeed-sgpio.o
+obj-$(CONFIG_GPIO_ATCGPIO100) += gpio-atcgpio100.o
obj-$(CONFIG_GPIO_ATH79) += gpio-ath79.o
obj-$(CONFIG_GPIO_AXIADO_SGPIO) += gpio-axiado-sgpio.o
obj-$(CONFIG_GPIO_BCM_KONA) += gpio-bcm-kona.o
diff --git a/drivers/gpio/gpio-atcgpio100.c b/drivers/gpio/gpio-atcgpio100.c
new file mode 100644
index 000000000000..2bc6847638db
--- /dev/null
+++ b/drivers/gpio/gpio-atcgpio100.c
@@ -0,0 +1,641 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Andes ATCGPIO100 controller driver.
+ *
+ * Copyright (C) 2026 Andes Technology Corporation
+ */
+
+#include <linux/bitfield.h>
+#include <linux/bits.h>
+#include <linux/clk.h>
+#include <linux/dev_printk.h>
+#include <linux/err.h>
+#include <linux/find.h>
+#include <linux/gpio/driver.h>
+#include <linux/gpio/generic.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/irqchip/chained_irq.h>
+#include <linux/math.h>
+#include <linux/minmax.h>
+#include <linux/mod_devicetable.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/pm.h>
+#include <linux/types.h>
+
+#define REG_CONFIG 0x10
+#define REG_DATA_IN 0x20
+#define REG_DATA_OUT 0x24
+#define REG_CHAN_DIR 0x28
+#define REG_CHAN_PULL_EN 0x40
+#define REG_CHAN_PULL_TYPE 0x44
+#define REG_CHAN_INT_EN 0x50
+#define REG_INT_MODE0 0x54
+#define REG_INT_MODE1 0x58
+#define REG_INT_MODE2 0x5c
+#define REG_INT_MODE3 0x60
+#define REG_CHAN_INT_STATE 0x64
+#define REG_DEBOUNCE_EN 0x70
+#define REG_DEBOUNCE_CTRL 0x74
+
+#define CONFIG_PULL_OPTION BIT(31)
+#define CONFIG_INT_OPTION BIT(30)
+#define CONFIG_DEBOUNCE_OPTION BIT(29)
+#define CONFIG_DEBOUNCE_CTRL_CLK_SEL BIT(31)
+#define CONFIG_DEBOUNCE_CTRL_MASK \
+ (CONFIG_DEBOUNCE_CTRL_CLK_SEL | GENMASK(7, 0))
+#define CONFIG_DEBOUNCE_MAX_CYCLES 256
+#define CONFIG_PULL_TYPE_UP 0
+#define CONFIG_PULL_TYPE_DOWN 1
+#define CONFIG_CHAN_NUM_MSK GENMASK(5, 0)
+#define CONFIG_CHAN_NUM_GET(x) FIELD_GET(CONFIG_CHAN_NUM_MSK, x)
+
+#define INT_MODE_TYPE_REG_OFFSET(gpio) (REG_INT_MODE0 + (((gpio) >> 3) << 2))
+#define INT_MODE_TYPE_SHIFT(gpio) (((gpio) % 8) << 2)
+#define INT_MODE_TYPE_MASK(gpio) \
+ (GENMASK(2, 0) << INT_MODE_TYPE_SHIFT(gpio))
+#define INT_MODE_LEVEL_HIGH 2
+#define INT_MODE_LEVEL_LOW 3
+#define INT_MODE_EDGE_NEGATIVE 5
+#define INT_MODE_EDGE_POSITIVE 6
+#define INT_MODE_EDGE_DUAL 7
+#define INT_MODE_REG_NUM 4
+
+#define ATCGPIO_CHAN_NUM_MAX 32
+
+/**
+ * struct atcgpio_context - Registers saved across system suspend
+ * @data_out: Channel data-out register
+ * @dir: Channel direction register
+ * @pull_en: Channel pull enable register
+ * @pull_type: Channel pull type register
+ * @int_mode: Channel interrupt mode registers
+ * @debounce_en: Channel de-bounce enable register
+ * @debounce_ctrl: De-bounce control register
+ */
+struct atcgpio_context {
+ u32 data_out;
+ u32 dir;
+ u32 pull_en;
+ u32 pull_type;
+ u32 int_mode[INT_MODE_REG_NUM];
+ u32 debounce_en;
+ u32 debounce_ctrl;
+};
+
+/**
+ * struct atcgpio_priv - Private data structure for ATCGPIO100 controller
+ * @chip: Generic GPIO chip, also provides the register lock
+ * @pdev: Pointer to the platform device
+ * @base: Base address of the controller registers
+ * @ctx: Registers saved across system suspend
+ * @int_en: Shadow of the channel interrupt enable register
+ * @extclk_rate: Frequency of external clock for debounce calculations
+ * @pclk_rate: Frequency of APB bus clock for debounce calculations
+ * @irq_parent: Parent IRQ number connected to the interrupt controller
+ * @chan_num: Number of GPIO channels supported by the hardware
+ * @pull_option: Indicates hardware support for pull-up/down resistors
+ * @int_option: Indicates hardware support for interrupts
+ * @debounce_option: Indicates hardware support for input debouncing
+ */
+struct atcgpio_priv {
+ struct gpio_generic_chip chip;
+ struct platform_device *pdev;
+ void __iomem *base;
+ struct atcgpio_context ctx;
+ u32 int_en;
+ unsigned int extclk_rate;
+ unsigned int pclk_rate;
+ int irq_parent;
+ unsigned char chan_num;
+ bool pull_option;
+ bool int_option;
+ bool debounce_option;
+};
+
+static u32 atcgpio_read(struct atcgpio_priv *priv, unsigned int reg)
+{
+ return readl(priv->base + reg);
+}
+
+static void atcgpio_write(struct atcgpio_priv *priv, unsigned int reg, u32 val)
+{
+ writel(val, priv->base + reg);
+}
+
+static void atcgpio_update_bits(struct atcgpio_priv *priv, unsigned int reg,
+ u32 mask, u32 val)
+{
+ u32 tmp;
+
+ tmp = atcgpio_read(priv, reg);
+ tmp = (tmp & ~mask) | (val & mask);
+ atcgpio_write(priv, reg, tmp);
+}
+
+/*
+ * Convert a de-bounce period to clock cycles, rounded up so that the filter
+ * is at least as long as requested. Zero if the clock is not available.
+ */
+static u64 atcgpio_calc_cycles(u32 clk_rate, u32 debounce_us)
+{
+ if (!clk_rate)
+ return 0;
+
+ return DIV_ROUND_UP_ULL((u64)debounce_us * clk_rate, 1000000);
+}
+
+static int atcgpio_set_debounce(struct atcgpio_priv *priv,
+ unsigned int gpio,
+ unsigned int debounce_us)
+{
+ unsigned long flags;
+ u64 ext_cycles, pclk_cycles, cycles;
+ u32 ctrl_val;
+ u32 active_users, current_ctrl;
+
+ if (!debounce_us) {
+ gpio_generic_chip_lock_irqsave(&priv->chip, flags);
+ atcgpio_update_bits(priv, REG_DEBOUNCE_EN, BIT(gpio), 0);
+ gpio_generic_chip_unlock_irqrestore(&priv->chip, flags);
+ return 0;
+ }
+
+ pclk_cycles = atcgpio_calc_cycles(priv->pclk_rate, debounce_us);
+ ext_cycles = atcgpio_calc_cycles(priv->extclk_rate, debounce_us);
+
+ /*
+ * Prefer pclk, the faster clock, for a shorter de-bounce latency, as
+ * long as the period fits in its pre-scaler; else use extclk. Reject
+ * a period that neither clock can reach.
+ */
+ if (pclk_cycles && pclk_cycles <= CONFIG_DEBOUNCE_MAX_CYCLES) {
+ cycles = pclk_cycles;
+ ctrl_val = CONFIG_DEBOUNCE_CTRL_CLK_SEL;
+ } else if (ext_cycles && ext_cycles <= CONFIG_DEBOUNCE_MAX_CYCLES) {
+ cycles = ext_cycles;
+ ctrl_val = 0;
+ } else {
+ gpio_generic_chip_lock_irqsave(&priv->chip, flags);
+ atcgpio_update_bits(priv, REG_DEBOUNCE_EN, BIT(gpio), 0);
+ gpio_generic_chip_unlock_irqrestore(&priv->chip, flags);
+ return -ENOTSUPP;
+ }
+
+ /* Filtering pulses shorter than N clocks takes a pre-scale of N - 1 */
+ ctrl_val |= (u32)(cycles - 1) & GENMASK(7, 0);
+
+ gpio_generic_chip_lock_irqsave(&priv->chip, flags);
+
+ active_users = atcgpio_read(priv, REG_DEBOUNCE_EN);
+ current_ctrl = atcgpio_read(priv, REG_DEBOUNCE_CTRL);
+
+ active_users &= ~BIT(gpio);
+ current_ctrl &= CONFIG_DEBOUNCE_CTRL_MASK;
+
+ if (active_users && current_ctrl != ctrl_val) {
+ atcgpio_update_bits(priv, REG_DEBOUNCE_EN, BIT(gpio), 0);
+ gpio_generic_chip_unlock_irqrestore(&priv->chip, flags);
+ return -ENOTSUPP;
+ }
+
+ atcgpio_update_bits(priv, REG_DEBOUNCE_CTRL,
+ CONFIG_DEBOUNCE_CTRL_MASK, ctrl_val);
+ atcgpio_update_bits(priv, REG_DEBOUNCE_EN, BIT(gpio), BIT(gpio));
+
+ gpio_generic_chip_unlock_irqrestore(&priv->chip, flags);
+
+ return 0;
+}
+
+static int atcgpio_set_pull_type(struct atcgpio_priv *priv,
+ unsigned int gpio,
+ bool pull_type,
+ bool pull_en)
+{
+ unsigned long flags;
+
+ gpio_generic_chip_lock_irqsave(&priv->chip, flags);
+ if (pull_en) {
+ atcgpio_update_bits(priv, REG_CHAN_PULL_TYPE, BIT(gpio),
+ pull_type ? BIT(gpio) : 0);
+ atcgpio_update_bits(priv, REG_CHAN_PULL_EN, BIT(gpio),
+ BIT(gpio));
+ } else {
+ atcgpio_update_bits(priv, REG_CHAN_PULL_EN, BIT(gpio), 0);
+ }
+ gpio_generic_chip_unlock_irqrestore(&priv->chip, flags);
+
+ return 0;
+}
+
+static int atcgpio_set_config(struct gpio_chip *gc,
+ unsigned int offset,
+ unsigned long config)
+{
+ struct atcgpio_priv *priv = gpiochip_get_data(gc);
+ unsigned int debounce_us;
+ int ret = -ENOTSUPP;
+
+ switch (pinconf_to_config_param(config)) {
+ case PIN_CONFIG_BIAS_DISABLE:
+ if (priv->pull_option)
+ ret = atcgpio_set_pull_type(priv, offset, 0, 0);
+ break;
+ case PIN_CONFIG_BIAS_PULL_UP:
+ if (priv->pull_option)
+ ret = atcgpio_set_pull_type(priv,
+ offset,
+ CONFIG_PULL_TYPE_UP, 1);
+ break;
+ case PIN_CONFIG_BIAS_PULL_DOWN:
+ if (priv->pull_option)
+ ret = atcgpio_set_pull_type(priv,
+ offset,
+ CONFIG_PULL_TYPE_DOWN, 1);
+ break;
+ case PIN_CONFIG_INPUT_DEBOUNCE:
+ if (priv->debounce_option) {
+ debounce_us = pinconf_to_config_argument(config);
+ ret = atcgpio_set_debounce(priv, offset, debounce_us);
+ }
+ break;
+ default:
+ break;
+ }
+
+ return ret;
+}
+
+static void atcgpio_free(struct gpio_chip *gc, unsigned int offset)
+{
+ struct atcgpio_priv *priv = gpiochip_get_data(gc);
+ unsigned long flags;
+
+ if (!priv->debounce_option)
+ return;
+
+ gpio_generic_chip_lock_irqsave(&priv->chip, flags);
+ atcgpio_update_bits(priv, REG_DEBOUNCE_EN, BIT(offset), 0);
+ gpio_generic_chip_unlock_irqrestore(&priv->chip, flags);
+}
+
+static void atcgpio_ack_irq(struct irq_data *data)
+{
+ struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
+ struct atcgpio_priv *priv = gpiochip_get_data(gc);
+ unsigned int gpio = irqd_to_hwirq(data);
+
+ atcgpio_write(priv, REG_CHAN_INT_STATE, BIT(gpio));
+}
+
+static void atcgpio_enable_irq(struct atcgpio_priv *priv,
+ unsigned int gpio,
+ bool enable)
+{
+ unsigned long flags;
+
+ gpio_generic_chip_lock_irqsave(&priv->chip, flags);
+ if (enable)
+ priv->int_en |= BIT(gpio);
+ else
+ priv->int_en &= ~BIT(gpio);
+ atcgpio_write(priv, REG_CHAN_INT_EN, priv->int_en);
+ gpio_generic_chip_unlock_irqrestore(&priv->chip, flags);
+}
+
+static void atcgpio_set_irq_unmask(struct irq_data *data)
+{
+ struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
+ struct atcgpio_priv *priv = gpiochip_get_data(gc);
+ unsigned int gpio = irqd_to_hwirq(data);
+
+ gpiochip_enable_irq(gc, gpio);
+ atcgpio_enable_irq(priv, gpio, 1);
+}
+
+static void atcgpio_set_irq_mask(struct irq_data *data)
+{
+ struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
+ struct atcgpio_priv *priv = gpiochip_get_data(gc);
+ unsigned int gpio = irqd_to_hwirq(data);
+
+ atcgpio_enable_irq(priv, gpio, 0);
+ gpiochip_disable_irq(gc, gpio);
+}
+
+static int atcgpio_set_irq_type(struct irq_data *data, unsigned int type)
+{
+ struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
+ struct atcgpio_priv *priv = gpiochip_get_data(gc);
+ irq_flow_handler_t handler;
+ unsigned long flags;
+ unsigned int gpio = irqd_to_hwirq(data);
+ unsigned char type_offset;
+ unsigned char irq_type;
+
+ type_offset = INT_MODE_TYPE_SHIFT(gpio);
+
+ switch (type) {
+ case IRQ_TYPE_EDGE_RISING:
+ irq_type = INT_MODE_EDGE_POSITIVE;
+ handler = handle_edge_irq;
+ break;
+ case IRQ_TYPE_EDGE_FALLING:
+ irq_type = INT_MODE_EDGE_NEGATIVE;
+ handler = handle_edge_irq;
+ break;
+ case IRQ_TYPE_EDGE_BOTH:
+ irq_type = INT_MODE_EDGE_DUAL;
+ handler = handle_edge_irq;
+ break;
+ case IRQ_TYPE_LEVEL_HIGH:
+ irq_type = INT_MODE_LEVEL_HIGH;
+ handler = handle_level_irq;
+ break;
+ case IRQ_TYPE_LEVEL_LOW:
+ irq_type = INT_MODE_LEVEL_LOW;
+ handler = handle_level_irq;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ gpio_generic_chip_lock_irqsave(&priv->chip, flags);
+ atcgpio_update_bits(priv, INT_MODE_TYPE_REG_OFFSET(gpio),
+ INT_MODE_TYPE_MASK(gpio), irq_type << type_offset);
+ atcgpio_write(priv, REG_CHAN_INT_STATE, BIT(gpio));
+ gpio_generic_chip_unlock_irqrestore(&priv->chip, flags);
+ irq_set_handler_locked(data, handler);
+
+ return 0;
+}
+
+static void atcgpio_irq_handler(struct irq_desc *desc)
+{
+ struct gpio_chip *gc = irq_desc_get_handler_data(desc);
+ struct atcgpio_priv *priv = gpiochip_get_data(gc);
+ unsigned long status;
+ int offset;
+
+ chained_irq_enter(irq_desc_get_chip(desc), desc);
+
+ status = atcgpio_read(priv, REG_CHAN_INT_STATE);
+ if (unlikely(!status)) {
+ dev_warn_ratelimited(gc->parent, "Spurious IRQ: status is 0\n");
+ goto irq_out;
+ }
+
+ for_each_set_bit(offset, &status, gc->ngpio)
+ generic_handle_domain_irq(gc->irq.domain, offset);
+
+irq_out:
+ chained_irq_exit(irq_desc_get_chip(desc), desc);
+}
+
+static int atcgpio_irq_set_wake(struct irq_data *data, unsigned int on)
+{
+ struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
+ struct atcgpio_priv *priv = gpiochip_get_data(gc);
+ int ret;
+
+ if (on)
+ ret = enable_irq_wake(priv->irq_parent);
+ else
+ ret = disable_irq_wake(priv->irq_parent);
+
+ return ret;
+}
+
+static const struct irq_chip atcgpio_irqchip = {
+ .name = "gpio-atcgpio100",
+ .irq_ack = atcgpio_ack_irq,
+ .irq_mask = atcgpio_set_irq_mask,
+ .irq_unmask = atcgpio_set_irq_unmask,
+ .irq_set_type = atcgpio_set_irq_type,
+ .irq_set_wake = atcgpio_irq_set_wake,
+ .flags = IRQCHIP_IMMUTABLE | IRQCHIP_SET_TYPE_MASKED |
+ IRQCHIP_MASK_ON_SUSPEND,
+ GPIOCHIP_IRQ_RESOURCE_HELPERS,
+};
+
+static int atcgpio_init_resources(struct atcgpio_priv *priv)
+{
+ struct gpio_generic_chip_config config;
+ struct clk *clk_debounce;
+ int ret;
+
+ priv->base = devm_platform_get_and_ioremap_resource(priv->pdev, 0, NULL);
+ if (IS_ERR(priv->base))
+ return dev_err_probe(&priv->pdev->dev, PTR_ERR(priv->base),
+ "Failed to get ioremap resource\n");
+
+ clk_debounce = devm_clk_get_enabled(&priv->pdev->dev, "pclk");
+ if (IS_ERR(clk_debounce))
+ return dev_err_probe(&priv->pdev->dev, PTR_ERR(clk_debounce),
+ "Failed to get pclk\n");
+ priv->pclk_rate = clk_get_rate(clk_debounce);
+
+ clk_debounce = devm_clk_get_optional_enabled(&priv->pdev->dev,
+ "extclk");
+ if (clk_debounce == ERR_PTR(-EPROBE_DEFER))
+ return dev_err_probe(&priv->pdev->dev, -EPROBE_DEFER,
+ "Failed to get extclk\n");
+ if (IS_ERR(clk_debounce)) {
+ dev_warn(&priv->pdev->dev, "Failed to get extclk: %pe\n",
+ clk_debounce);
+ priv->extclk_rate = 0;
+ } else {
+ priv->extclk_rate = clk_get_rate(clk_debounce);
+ }
+
+ config = (struct gpio_generic_chip_config) {
+ .dev = &priv->pdev->dev,
+ .sz = 4,
+ .dat = priv->base + REG_DATA_IN,
+ .set = priv->base + REG_DATA_OUT,
+ .dirout = priv->base + REG_CHAN_DIR,
+ .flags = GPIO_GENERIC_READ_OUTPUT_REG_SET,
+ };
+
+ ret = gpio_generic_chip_init(&priv->chip, &config);
+ if (ret)
+ return dev_err_probe(&priv->pdev->dev, ret,
+ "Failed to init generic GPIO chip\n");
+
+ return 0;
+}
+
+static void atcgpio_init_controller(struct atcgpio_priv *priv)
+{
+ u32 cfg;
+
+ cfg = atcgpio_read(priv, REG_CONFIG);
+ priv->pull_option = !!(cfg & CONFIG_PULL_OPTION);
+ priv->int_option = !!(cfg & CONFIG_INT_OPTION);
+ priv->debounce_option = !!(cfg & CONFIG_DEBOUNCE_OPTION);
+ priv->chan_num = CONFIG_CHAN_NUM_GET(cfg);
+ if (priv->chan_num > ATCGPIO_CHAN_NUM_MAX || !priv->chan_num) {
+ dev_warn(&priv->pdev->dev,
+ "Invalid hardware GPIO number %d, forcing to %d\n",
+ priv->chan_num,
+ ATCGPIO_CHAN_NUM_MAX);
+ priv->chan_num = ATCGPIO_CHAN_NUM_MAX;
+ }
+
+ if (!priv->extclk_rate && !priv->pclk_rate) {
+ dev_warn(&priv->pdev->dev,
+ "Disabling debounce: missing reference clock\n");
+ priv->debounce_option = 0;
+ }
+
+ if (priv->debounce_option)
+ atcgpio_write(priv, REG_DEBOUNCE_EN, 0);
+
+ if (priv->int_option) {
+ atcgpio_write(priv, REG_CHAN_INT_EN, 0);
+ atcgpio_write(priv, REG_INT_MODE0, 0);
+ atcgpio_write(priv, REG_INT_MODE1, 0);
+ atcgpio_write(priv, REG_INT_MODE2, 0);
+ atcgpio_write(priv, REG_INT_MODE3, 0);
+ atcgpio_write(priv, REG_CHAN_INT_STATE, GENMASK(31, 0));
+ }
+}
+
+static int atcgpio_probe(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ struct gpio_irq_chip *gc_irq;
+ struct atcgpio_priv *priv;
+ struct gpio_chip *gc;
+ int ret;
+
+ priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
+ priv->pdev = pdev;
+ ret = atcgpio_init_resources(priv);
+ if (ret)
+ return ret;
+
+ atcgpio_init_controller(priv);
+
+ gc = &priv->chip.gc;
+ gc->owner = THIS_MODULE;
+ gc->set_config = atcgpio_set_config;
+ gc->free = atcgpio_free;
+ gc->ngpio = min_t(unsigned int, gc->ngpio, priv->chan_num);
+
+ if (priv->int_option) {
+ priv->irq_parent = platform_get_irq_optional(pdev, 0);
+ if (priv->irq_parent == -EPROBE_DEFER)
+ return dev_err_probe(dev, priv->irq_parent,
+ "Failed to get IRQ\n");
+ if (priv->irq_parent < 0) {
+ dev_info(dev, "No IRQ, interrupt support disabled\n");
+ priv->int_option = false;
+ }
+ }
+
+ if (priv->int_option) {
+ gc_irq = &gc->irq;
+ gpio_irq_chip_set_chip(gc_irq, &atcgpio_irqchip);
+ gc_irq->parent_handler = atcgpio_irq_handler;
+ gc_irq->num_parents = 1;
+ gc_irq->parents = devm_kcalloc(dev, gc_irq->num_parents,
+ sizeof(*gc_irq->parents),
+ GFP_KERNEL);
+ if (!gc_irq->parents)
+ return -ENOMEM;
+ gc_irq->parents[0] = priv->irq_parent;
+ gc_irq->default_type = IRQ_TYPE_NONE;
+ gc_irq->handler = handle_bad_irq;
+ }
+
+ platform_set_drvdata(pdev, priv);
+ return devm_gpiochip_add_data(dev, gc, priv);
+}
+
+static int atcgpio_suspend(struct device *dev)
+{
+ struct atcgpio_priv *priv = dev_get_drvdata(dev);
+ struct atcgpio_context *ctx = &priv->ctx;
+ unsigned long flags;
+
+ gpio_generic_chip_lock_irqsave(&priv->chip, flags);
+ ctx->data_out = atcgpio_read(priv, REG_DATA_OUT);
+ ctx->dir = atcgpio_read(priv, REG_CHAN_DIR);
+ if (priv->pull_option) {
+ ctx->pull_en = atcgpio_read(priv, REG_CHAN_PULL_EN);
+ ctx->pull_type = atcgpio_read(priv, REG_CHAN_PULL_TYPE);
+ }
+ if (priv->int_option) {
+ ctx->int_mode[0] = atcgpio_read(priv, REG_INT_MODE0);
+ ctx->int_mode[1] = atcgpio_read(priv, REG_INT_MODE1);
+ ctx->int_mode[2] = atcgpio_read(priv, REG_INT_MODE2);
+ ctx->int_mode[3] = atcgpio_read(priv, REG_INT_MODE3);
+ }
+ if (priv->debounce_option) {
+ ctx->debounce_en = atcgpio_read(priv, REG_DEBOUNCE_EN);
+ ctx->debounce_ctrl = atcgpio_read(priv, REG_DEBOUNCE_CTRL);
+ }
+ gpio_generic_chip_unlock_irqrestore(&priv->chip, flags);
+
+ return 0;
+}
+
+static int atcgpio_resume(struct device *dev)
+{
+ struct atcgpio_priv *priv = dev_get_drvdata(dev);
+ struct atcgpio_context *ctx = &priv->ctx;
+ unsigned long flags;
+
+ gpio_generic_chip_lock_irqsave(&priv->chip, flags);
+ atcgpio_write(priv, REG_DATA_OUT, ctx->data_out);
+ if (priv->pull_option) {
+ atcgpio_write(priv, REG_CHAN_PULL_TYPE, ctx->pull_type);
+ atcgpio_write(priv, REG_CHAN_PULL_EN, ctx->pull_en);
+ }
+ atcgpio_write(priv, REG_CHAN_DIR, ctx->dir);
+ if (priv->debounce_option) {
+ atcgpio_write(priv, REG_DEBOUNCE_CTRL, ctx->debounce_ctrl);
+ atcgpio_write(priv, REG_DEBOUNCE_EN, ctx->debounce_en);
+ }
+ if (priv->int_option) {
+ atcgpio_write(priv, REG_INT_MODE0, ctx->int_mode[0]);
+ atcgpio_write(priv, REG_INT_MODE1, ctx->int_mode[1]);
+ atcgpio_write(priv, REG_INT_MODE2, ctx->int_mode[2]);
+ atcgpio_write(priv, REG_INT_MODE3, ctx->int_mode[3]);
+ atcgpio_write(priv, REG_CHAN_INT_EN, priv->int_en);
+ }
+ gpio_generic_chip_unlock_irqrestore(&priv->chip, flags);
+
+ return 0;
+}
+
+static DEFINE_NOIRQ_DEV_PM_OPS(atcgpio_pm_ops,
+ atcgpio_suspend, atcgpio_resume);
+
+static const struct of_device_id atcgpio100_gpio_match[] = {
+ { .compatible = "andestech,ae350-gpio" },
+ { }
+};
+MODULE_DEVICE_TABLE(of, atcgpio100_gpio_match);
+
+static struct platform_driver atcgpio100_gpio_driver = {
+ .probe = atcgpio_probe,
+ .driver = {
+ .name = "atcgpio100",
+ .of_match_table = atcgpio100_gpio_match,
+ .pm = pm_sleep_ptr(&atcgpio_pm_ops),
+ }
+};
+
+module_platform_driver(atcgpio100_gpio_driver);
+
+MODULE_DESCRIPTION("Andes ATCGPIO100 GPIO controller driver");
+MODULE_AUTHOR("CL Wang <cl634@andestech.com>");
+MODULE_LICENSE("GPL");
--
2.34.1
^ permalink raw reply related [flat|nested] 4+ messages in thread
* [PATCH 3/3] MAINTAINERS: Add entry for Andes ATCGPIO100 GPIO
2026-11-16 4:09 [PATCH 0/3] gpio: Add support for Andes ATCGPIO100 GPIO controller CL Wang
2026-11-16 4:09 ` [PATCH 1/3] dt-bindings: gpio: Add support for " CL Wang
2026-11-16 4:09 ` [PATCH 2/3] gpio: atcgpio100: Add ATCGPIO100 GPIO driver CL Wang
@ 2026-11-16 4:09 ` CL Wang
2 siblings, 0 replies; 4+ messages in thread
From: CL Wang @ 2026-11-16 4:09 UTC (permalink / raw)
To: Linus Walleij, Bartosz Golaszewski, Rob Herring,
Krzysztof Kozlowski, Conor Dooley
Cc: CL Wang, linux-gpio, devicetree, linux-kernel, tim609
Add MAINTAINERS entry for the Andes ATCGPIO100 GPIO controller driver.
Signed-off-by: CL Wang <cl634@andestech.com>
---
MAINTAINERS | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/MAINTAINERS b/MAINTAINERS
index 222b7fc2c3aa..ba1930a37596 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2042,6 +2042,12 @@ S: Supported
F: drivers/clk/analogbits/*
F: include/linux/clk/analogbits*
+ANDES ATCGPIO100 GPIO DRIVER
+M: CL Wang <cl634@andestech.com>
+S: Supported
+F: Documentation/devicetree/bindings/gpio/andestech,ae350-gpio.yaml
+F: drivers/gpio/gpio-atcgpio100.c
+
ANDES ATCSPI200 SPI DRIVER
M: CL Wang <cl634@andestech.com>
S: Supported
--
2.34.1
^ permalink raw reply related [flat|nested] 4+ messages in thread
end of thread, other threads:[~2026-11-16 4:09 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-16 4:09 [PATCH 0/3] gpio: Add support for Andes ATCGPIO100 GPIO controller CL Wang
2026-11-16 4:09 ` [PATCH 1/3] dt-bindings: gpio: Add support for " CL Wang
2026-11-16 4:09 ` [PATCH 2/3] gpio: atcgpio100: Add ATCGPIO100 GPIO driver CL Wang
2026-11-16 4:09 ` [PATCH 3/3] MAINTAINERS: Add entry for Andes ATCGPIO100 GPIO CL Wang
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox