* [PATCH v4] gpio: amdptpci: add support for AMD PT PCI controller
@ 2026-11-16 7:55 Szuying Chen
2026-11-16 10:03 ` Markus Elfring
0 siblings, 1 reply; 2+ messages in thread
From: Szuying Chen @ 2026-11-16 7:55 UTC (permalink / raw)
To: linusw, Markus.Elfring, linux-gpio, brgl, linux-kernel
Cc: Yd_Tseng, Jesse1_Chang, Richard_Hsu, Szuying Chen
The GPIO controller on AMD PT PCI platforms currently has no in-tree
driver, so its pins cannot be used from Linux.
The existing gpio-amdpt driver cannot be reused. Setting aside ACPI
vs. PCI probing, the hardware differs significantly:
- Register semantics conflict: offset 0x0C controls the clock rate
in gpio-amdpt but enables interrupts in this controller.
- Interrupt controller: gpio-amdpt has no interrupt support, while
this controller has its own INT_LVL, INT_STAT and INT_MASK
registers that require a full irq_chip implementation.
- Wakeup: this controller can wake the system from GPIO interrupts,
which gpio-amdpt does not support.
Only the basic data registers are common, and they are handled
through gpio-generic, so little code is left to share.
Add the gpio-amdptpci driver to support the GPIO functionality on
AMD PT PCI platforms.
Co-developed-by: YD Tseng <Yd_Tseng@asmedia.com.tw>
Signed-off-by: YD Tseng <Yd_Tseng@asmedia.com.tw>
Signed-off-by: Szuying Chen <Chloe_Chen@asmedia.com.tw>
---
V3->V4:
-Kconfig: select GPIO_GENERIC & GPIO_GPIOLIB_IRQCHIP.
-Use Chip->gen.lock for all register accesses.
-Keep the controller in D0 while a GPIO IRQ is requested.
-prode: reorder devres for a safe unbind sequence.
-Fix build error.
V2->V3:
- Rework the driver to use gpio-generic.
- Move runtime PM handling to gpio_chip request() and
free() callbacks.
- Simplify locking with guard() and scoped_guard().
- Use devm_add_action_or_reset() for resource cleanup.
- Add rationale for a separate driver to the commit message.
- Regmap was evaluated but not used: the registers are mix of
8/16/32 bit and it would need more callbacks to define, which
complicates the code.
v1->v2:
- Add .irq_request/release_resources to set irq_pm_held flag.
- switch to devres in probe/remove.
- Add synchronize_irq().
---
drivers/gpio/Kconfig | 8 +
drivers/gpio/Makefile | 1 +
drivers/gpio/gpio-amdptpci.c | 634 +++++++++++++++++++++++++++++++++++
3 files changed, 643 insertions(+)
create mode 100644 drivers/gpio/gpio-amdptpci.c
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index a48586bb8edb..a10e96b5295f 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -1833,6 +1833,14 @@ endmenu
menu "PCI GPIO expanders"
depends on PCI
+config GPIO_AMDPTPCI
+ tristate "AMD Promontory PCI GPIO support"
+ depends on X86
+ select GPIO_GENERIC
+ select GPIOLIB_IRQCHIP
+ help
+ Driver for Promontory IOHub PCI GPIO functionality.
+
config GPIO_AMD8111
tristate "AMD 8111 GPIO driver"
depends on X86 || COMPILE_TEST
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index dc9e6d643b5b..ca26e98fc8e8 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -36,6 +36,7 @@ obj-$(CONFIG_GPIO_ALTERA) += gpio-altera.o
obj-$(CONFIG_GPIO_AMD8111) += gpio-amd8111.o
obj-$(CONFIG_GPIO_AMD_FCH) += gpio-amd-fch.o
obj-$(CONFIG_GPIO_AMDPT) += gpio-amdpt.o
+obj-$(CONFIG_GPIO_AMDPTPCI) += gpio-amdptpci.o
obj-$(CONFIG_GPIO_ARIZONA) += gpio-arizona.o
obj-$(CONFIG_GPIO_ASPEED) += gpio-aspeed.o
obj-$(CONFIG_GPIO_ASPEED_SGPIO) += gpio-aspeed-sgpio.o
diff --git a/drivers/gpio/gpio-amdptpci.c b/drivers/gpio/gpio-amdptpci.c
new file mode 100644
index 000000000000..d676fd8c0b1c
--- /dev/null
+++ b/drivers/gpio/gpio-amdptpci.c
@@ -0,0 +1,634 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * gpio-amdptpci.c - AMD Promontory PCI GPIO Controller Driver
+ *
+ * Copyright (C) 2026 ASMedia Technology Inc.
+ * Author: Chloe Chen <chloe_chen@asmedia.com.tw>
+ * YD Tseng <yd_tseng@asmedia.com.tw>
+ */
+
+#include <linux/bits.h>
+#include <linux/gpio/driver.h>
+#include <linux/gpio/generic.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/pm.h>
+#include <linux/pm_runtime.h>
+#include <linux/pm_wakeup.h>
+#include <linux/spinlock.h>
+#include <linux/types.h>
+
+#define PT27_NUM_GPIOS 24
+#define PT27_WAKE_GPIOS 12
+#define PT27_GPIO_MASK GENMASK(PT27_NUM_GPIOS - 1, 0)
+#define PT27_WAKE_MASK GENMASK(PT27_WAKE_GPIOS - 1, 0)
+
+#define PT27_REG_DIR 0x0000
+#define PT27_REG_IN 0x0004
+#define PT27_REG_OUT 0x0008
+#define PT27_REG_INT_EN 0x000C
+#define PT27_REG_INT_LVL 0x0010
+#define PT27_REG_INT_MODE0 0x0014
+#define PT27_REG_INT_MODE1 0x0018
+#define PT27_REG_INT_STAT 0x001C
+#define PT27_REG_INT_MASK 0x0020
+#define PT27_REG_INT_CTL 0x0024
+
+#define PT27_REG_WAKE_EN 0x0034
+#define PT27_REG_WAKE_LVL 0x0036
+#define PT27_REG_WAKE_MODE 0x0038
+#define PT27_REG_WAKE_STAT 0x003A
+
+#define PT27_INT_MODE_MASK 0x3U
+#define PT27_MODE_LEVEL 0x0U
+#define PT27_MODE_RISING 0x1U
+#define PT27_MODE_FALLING 0x2U
+#define PT27_MODE_BOTH 0x3U
+
+#define PT27_INT_CTL_MODE BIT(0)
+#define PT27_INT_CTL_PAD_EN BIT(2)
+
+#define PT27_AUTOSUSPEND_DELAY_MS 2000
+
+struct pt27_saved_regs {
+ u32 dir;
+ u32 out;
+ u32 int_en;
+ u32 int_lvl;
+ u32 int_mode0;
+ u16 int_mode1;
+ u32 int_mask;
+ u8 int_ctl;
+ u16 wake_en;
+ u16 wake_lvl;
+ u16 wake_mode;
+};
+
+struct pt27_gpio {
+ struct device *dev;
+ struct gpio_generic_chip gen;
+ void __iomem *base;
+ struct pt27_saved_regs saved;
+ u16 wake_mask;
+ bool use_msi;
+ int irq;
+};
+
+static void pt27_save_regs(struct pt27_gpio *chip)
+{
+ chip->saved.dir = ioread32(chip->base + PT27_REG_DIR);
+ chip->saved.out = ioread32(chip->base + PT27_REG_OUT);
+
+ chip->saved.int_en = ioread32(chip->base + PT27_REG_INT_EN);
+ chip->saved.int_lvl = ioread32(chip->base + PT27_REG_INT_LVL);
+ chip->saved.int_mode0 = ioread32(chip->base + PT27_REG_INT_MODE0);
+ chip->saved.int_mode1 = ioread16(chip->base + PT27_REG_INT_MODE1);
+ chip->saved.int_mask = ioread32(chip->base + PT27_REG_INT_MASK);
+ chip->saved.int_ctl = ioread8(chip->base + PT27_REG_INT_CTL);
+
+ chip->saved.wake_en = ioread16(chip->base + PT27_REG_WAKE_EN);
+ chip->saved.wake_lvl = ioread16(chip->base + PT27_REG_WAKE_LVL);
+ chip->saved.wake_mode = ioread16(chip->base + PT27_REG_WAKE_MODE);
+}
+
+static void pt27_restore_regs(struct pt27_gpio *chip)
+{
+ iowrite32(chip->saved.out, chip->base + PT27_REG_OUT);
+ iowrite32(chip->saved.dir, chip->base + PT27_REG_DIR);
+
+ iowrite32(chip->saved.int_lvl, chip->base + PT27_REG_INT_LVL);
+ iowrite32(chip->saved.int_mode0, chip->base + PT27_REG_INT_MODE0);
+ iowrite16(chip->saved.int_mode1, chip->base + PT27_REG_INT_MODE1);
+ iowrite8(chip->saved.int_ctl, chip->base + PT27_REG_INT_CTL);
+
+ iowrite16(chip->saved.wake_lvl, chip->base + PT27_REG_WAKE_LVL);
+ iowrite16(chip->saved.wake_mode, chip->base + PT27_REG_WAKE_MODE);
+ iowrite16(chip->saved.wake_en, chip->base + PT27_REG_WAKE_EN);
+
+ iowrite32(chip->saved.int_en, chip->base + PT27_REG_INT_EN);
+ iowrite32(chip->saved.int_mask, chip->base + PT27_REG_INT_MASK);
+}
+
+static int pt27_gpio_request(struct gpio_chip *gc, unsigned int offset)
+{
+ int ret;
+
+ ret = pm_runtime_resume_and_get(gc->parent);
+ if (ret < 0) {
+ dev_err(gc->parent, "%s: cannot resume for GPIO%u: %d\n", __func__, offset, ret);
+ return ret;
+ }
+ return 0;
+}
+
+static void pt27_gpio_free(struct gpio_chip *gc, unsigned int offset)
+{
+ pm_runtime_put_autosuspend(gc->parent);
+
+}
+
+static int pt27_irq_reqres(struct irq_data *d)
+{
+ struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+ int ret;
+
+ ret = pm_runtime_resume_and_get(gc->parent);
+ if (ret < 0) {
+ dev_err(gc->parent, "%s: Fail to resume controller for IRQ: %d\n", __func__, ret);
+ return ret;
+ }
+
+ ret = gpiochip_reqres_irq(gc, irqd_to_hwirq(d));
+ if (ret) {
+ pm_runtime_put_autosuspend(gc->parent);
+ return ret;
+ }
+ return 0;
+}
+
+static void pt27_irq_relres(struct irq_data *d)
+{
+ struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+
+ gpiochip_relres_irq(gc, irqd_to_hwirq(d));
+ pm_runtime_put_autosuspend(gc->parent);
+}
+
+static void pt27_irq_mask(struct irq_data *d)
+{
+ struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+ struct pt27_gpio *chip = gpiochip_get_data(gc);
+ irq_hw_number_t hwirq = irqd_to_hwirq(d);
+ u32 val;
+
+ guard(raw_spinlock_irqsave)(&chip->gen.lock);
+
+ val = ioread32(chip->base + PT27_REG_INT_MASK);
+ val |= BIT(hwirq);
+ iowrite32(val, chip->base + PT27_REG_INT_MASK);
+
+ val = ioread32(chip->base + PT27_REG_INT_EN);
+ val &= ~BIT(hwirq);
+ iowrite32(val, chip->base + PT27_REG_INT_EN);
+
+ gpiochip_disable_irq(gc, hwirq);
+}
+
+static void pt27_irq_unmask(struct irq_data *d)
+{
+ struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+ struct pt27_gpio *chip = gpiochip_get_data(gc);
+ irq_hw_number_t hwirq = irqd_to_hwirq(d);
+ u32 val;
+
+ gpiochip_enable_irq(gc, hwirq);
+
+ guard(raw_spinlock_irqsave)(&chip->gen.lock);
+
+ val = ioread32(chip->base + PT27_REG_INT_EN);
+ val |= BIT(hwirq);
+ iowrite32(val, chip->base + PT27_REG_INT_EN);
+
+ val = ioread32(chip->base + PT27_REG_INT_MASK);
+ val &= ~BIT(hwirq);
+ iowrite32(val, chip->base + PT27_REG_INT_MASK);
+}
+
+static void pt27_irq_ack(struct irq_data *d)
+{
+ struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+ struct pt27_gpio *chip = gpiochip_get_data(gc);
+
+ iowrite32(BIT(irqd_to_hwirq(d)), chip->base + PT27_REG_INT_STAT);
+}
+
+static int pt27_irq_set_type(struct irq_data *d, unsigned int type)
+{
+ struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+ struct pt27_gpio *chip = gpiochip_get_data(gc);
+ irq_hw_number_t hwirq = irqd_to_hwirq(d);
+ u32 lvl_reg;
+ u8 lvl_bit, mode_val;
+ unsigned int shift;
+
+ switch (type) {
+ case IRQ_TYPE_LEVEL_HIGH:
+ lvl_bit = 1;
+ mode_val = PT27_MODE_LEVEL;
+ break;
+
+ case IRQ_TYPE_LEVEL_LOW:
+ lvl_bit = 0;
+ mode_val = PT27_MODE_LEVEL;
+ break;
+
+ case IRQ_TYPE_EDGE_RISING:
+ lvl_bit = 1;
+ mode_val = PT27_MODE_RISING;
+ break;
+
+ case IRQ_TYPE_EDGE_FALLING:
+ lvl_bit = 0;
+ mode_val = PT27_MODE_FALLING;
+ break;
+
+ case IRQ_TYPE_EDGE_BOTH:
+ lvl_bit = 0;
+ mode_val = PT27_MODE_BOTH;
+ break;
+
+ default:
+ return -EINVAL;
+
+ }
+
+ scoped_guard(raw_spinlock_irqsave, &chip->gen.lock) {
+ lvl_reg = ioread32(chip->base + PT27_REG_INT_LVL);
+ if (lvl_bit)
+ lvl_reg |= BIT(hwirq);
+ else
+ lvl_reg &= ~BIT(hwirq);
+
+ iowrite32(lvl_reg, chip->base + PT27_REG_INT_LVL);
+
+ if (hwirq < 16) {
+ u32 reg = ioread32(chip->base + PT27_REG_INT_MODE0);
+
+ shift = hwirq * 2;
+ reg &= ~(PT27_INT_MODE_MASK << shift);
+ reg |= ((u32)mode_val << shift);
+ iowrite32(reg, chip->base + PT27_REG_INT_MODE0);
+ } else {
+ u16 reg = ioread16(chip->base + PT27_REG_INT_MODE1);
+
+ shift = (hwirq - 16) * 2;
+ reg &= ~((u16)(PT27_INT_MODE_MASK << shift));
+ reg |= (u16)((u16)mode_val << shift);
+ iowrite16(reg, chip->base + PT27_REG_INT_MODE1);
+ }
+
+ iowrite32(BIT(hwirq), chip->base + PT27_REG_INT_STAT);
+
+ }
+
+ 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 int pt27_irq_set_wake(struct irq_data *d, unsigned int on)
+{
+ struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+ struct pt27_gpio *chip = gpiochip_get_data(gc);
+ irq_hw_number_t hwirq = irqd_to_hwirq(d);
+ unsigned int trig = irqd_get_trigger_type(d);
+ u16 wake_en, wake_lvl, wake_mode;
+
+ if (hwirq >= PT27_WAKE_GPIOS) {
+ dev_dbg(chip->dev, "%s: GPIO%lu does not support wake (max GPIO%u)\n", __func__, hwirq, PT27_WAKE_GPIOS - 1);
+ return -EINVAL;
+ }
+
+ if (on && trig == IRQ_TYPE_NONE)
+ return -EINVAL;
+
+ guard(raw_spinlock_irqsave)(&chip->gen.lock);
+
+ wake_en = ioread16(chip->base + PT27_REG_WAKE_EN);
+ wake_lvl = ioread16(chip->base + PT27_REG_WAKE_LVL);
+ wake_mode = ioread16(chip->base + PT27_REG_WAKE_MODE);
+
+ if (on) {
+ wake_en |= BIT(hwirq);
+ chip->wake_mask |= (u16)BIT(hwirq);
+
+ if (trig & IRQ_TYPE_LEVEL_MASK) {
+ wake_mode |= BIT(hwirq);
+ if (trig == IRQ_TYPE_LEVEL_HIGH)
+ wake_lvl |= BIT(hwirq);
+ else
+ wake_lvl &= ~BIT(hwirq);
+ } else {
+ wake_mode &= ~BIT(hwirq);
+ if (trig == IRQ_TYPE_EDGE_RISING ||
+ trig == IRQ_TYPE_EDGE_BOTH)
+ wake_lvl |= BIT(hwirq);
+ else
+ wake_lvl &= ~BIT(hwirq);
+ }
+ } else {
+ wake_en &= ~BIT(hwirq);
+ chip->wake_mask &= ~(u16)BIT(hwirq);
+ }
+
+ iowrite16(wake_lvl, chip->base + PT27_REG_WAKE_LVL);
+ iowrite16(wake_mode, chip->base + PT27_REG_WAKE_MODE);
+ iowrite16(wake_en, chip->base + PT27_REG_WAKE_EN);
+
+ return 0;
+}
+
+static const struct irq_chip pt27_gpio_irq_chip = {
+ .name = "pt27_gpio",
+ .irq_ack = pt27_irq_ack,
+ .irq_mask = pt27_irq_mask,
+ .irq_unmask = pt27_irq_unmask,
+ .irq_set_type = pt27_irq_set_type,
+ .irq_set_wake = pt27_irq_set_wake,
+ .irq_request_resources = pt27_irq_reqres,
+ .irq_release_resources = pt27_irq_relres,
+ .flags = IRQCHIP_IMMUTABLE,
+};
+
+static irqreturn_t pt27_gpio_isr(int irq, void *data)
+{
+ struct pt27_gpio *chip = data;
+ irqreturn_t ret = IRQ_NONE;
+ unsigned long pending;
+
+ if (pm_runtime_get_if_in_use(chip->dev) <= 0)
+ return IRQ_NONE;
+
+ scoped_guard(raw_spinlock_irqsave, &chip->gen.lock) {
+ pending = ioread32(chip->base + PT27_REG_INT_STAT) &
+ ~ioread32(chip->base + PT27_REG_INT_MASK) &
+ ioread32(chip->base + PT27_REG_INT_EN);
+ }
+
+ while (pending) {
+ unsigned int hwirq = __ffs(pending);
+
+ pending &= ~BIT(hwirq);
+ ret = IRQ_HANDLED;
+
+ if (generic_handle_domain_irq(chip->gen.gc.irq.domain, hwirq)) {
+
+ dev_warn_ratelimited(chip->dev, "unhandled GPIO%u IRQ, masking\n", hwirq);
+
+ guard(raw_spinlock_irqsave)(&chip->gen.lock);
+ iowrite32(ioread32(chip->base + PT27_REG_INT_MASK) | BIT(hwirq), chip->base + PT27_REG_INT_MASK);
+ iowrite32(ioread32(chip->base + PT27_REG_INT_EN) & ~BIT(hwirq), chip->base + PT27_REG_INT_EN);
+ iowrite32(BIT(hwirq), chip->base + PT27_REG_INT_STAT);
+ }
+ }
+
+ pm_runtime_put(chip->dev);
+ return ret;
+}
+
+static void pt27_hw_clear(void *data)
+{
+ struct pt27_gpio *chip = data;
+
+ iowrite32(0, chip->base + PT27_REG_INT_EN);
+ iowrite32(PT27_GPIO_MASK, chip->base + PT27_REG_INT_MASK);
+ iowrite32(PT27_GPIO_MASK, chip->base + PT27_REG_INT_STAT);
+ iowrite16(0, chip->base + PT27_REG_WAKE_EN);
+ iowrite16(PT27_WAKE_MASK, chip->base + PT27_REG_WAKE_STAT);
+}
+
+static void pt27_hw_init(struct pt27_gpio *chip)
+{
+ u8 int_ctl;
+
+ int_ctl = ioread8(chip->base + PT27_REG_INT_CTL);
+ int_ctl |= PT27_INT_CTL_MODE;
+ int_ctl &= ~PT27_INT_CTL_PAD_EN;
+ iowrite8(int_ctl, chip->base + PT27_REG_INT_CTL);
+
+ pt27_hw_clear(chip);
+}
+
+static int pt27_gpio_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+{
+ struct device *dev = &pdev->dev;
+ struct gpio_generic_chip_config config = { };
+ struct pt27_gpio *chip;
+ struct gpio_chip *gc;
+ struct gpio_irq_chip *girq;
+ unsigned long irq_flags;
+ int ret;
+
+ chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
+ if (!chip)
+ return -ENOMEM;
+
+ chip->dev = dev;
+ pci_set_drvdata(pdev, chip);
+
+ ret = pcim_enable_device(pdev);
+ if (ret)
+ return dev_err_probe(dev, ret, "failed to enable PCI device\n");
+
+ chip->base = pcim_iomap_region(pdev, 0, "pt27_gpio");
+ if (IS_ERR(chip->base))
+ return dev_err_probe(dev, PTR_ERR(chip->base), "failed to claim and map BAR0\n");
+
+ pci_set_master(pdev);
+
+ ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_ALL_TYPES);
+ if (ret < 0)
+ return dev_err_probe(dev, ret, "failed to allocate IRQ vector\n");
+
+ chip->use_msi = pdev->msi_enabled || pdev->msix_enabled;
+ irq_flags = chip->use_msi ? 0 : IRQF_SHARED;
+ chip->irq = pci_irq_vector(pdev, 0);
+
+ pt27_hw_init(chip);
+
+ config.dev = dev;
+ config.sz = 4;
+ config.dat = chip->base + PT27_REG_IN;
+ config.set = chip->base + PT27_REG_OUT;
+ config.dirout = chip->base + PT27_REG_DIR;
+ config.flags = GPIO_GENERIC_READ_OUTPUT_REG_SET;
+
+ ret = gpio_generic_chip_init(&chip->gen, &config);
+ if (ret)
+ return dev_err_probe(dev, ret, "generic chip init failed\n");
+
+ gc = &chip->gen.gc;
+ gc->label = dev_name(dev);
+ gc->parent = dev;
+ gc->owner = THIS_MODULE;
+ gc->base = -1;
+ gc->ngpio = PT27_NUM_GPIOS;
+ gc->request = pt27_gpio_request;
+ gc->free = pt27_gpio_free;
+
+ girq = &gc->irq;
+ gpio_irq_chip_set_chip(girq, &pt27_gpio_irq_chip);
+ girq->parent_handler = NULL;
+ girq->num_parents = 0;
+ girq->parents = NULL;
+ girq->default_type = IRQ_TYPE_NONE;
+ girq->handler = handle_bad_irq;
+
+ ret = devm_device_init_wakeup(dev);
+ if (ret)
+ return dev_err_probe(dev, ret, "failed to enable wake capability\n");
+
+ dev_pm_set_driver_flags(dev, DPM_FLAG_SMART_SUSPEND);
+
+ pm_runtime_set_autosuspend_delay(dev, PT27_AUTOSUSPEND_DELAY_MS);
+ pm_runtime_use_autosuspend(dev);
+
+ ret = devm_request_irq(dev, chip->irq, pt27_gpio_isr,
+ irq_flags | IRQF_NO_THREAD, dev_name(dev), chip);
+ if (ret) {
+ dev_err_probe(dev, ret, "failed to request IRQ %d\n", chip->irq);
+ goto err_pm_disable;
+ }
+
+ ret = devm_add_action_or_reset(dev, pt27_hw_clear, chip);
+ if (ret)
+ goto err_pm_disable;
+
+ ret = devm_gpiochip_add_data(dev, gc, chip);
+ if (ret) {
+ dev_err_probe(dev, ret, "failed to register GPIO chip\n");
+ goto err_pm_disable;
+ }
+
+ dev_info(dev,
+ "PT27 GPIO controller: %u GPIOs (%u wake-capable), IRQ=%d (%s)\n",
+ PT27_NUM_GPIOS, PT27_WAKE_GPIOS, chip->irq,
+ chip->use_msi ? (pdev->msix_enabled ? "MSI-X" : "MSI") : "INTx");
+
+ pm_runtime_put_noidle(dev);
+ pm_runtime_allow(dev);
+ return 0;
+
+err_pm_disable:
+ pm_runtime_dont_use_autosuspend(dev);
+ return ret;
+}
+
+static void pt27_gpio_remove(struct pci_dev *pdev)
+{
+ struct device *dev = &pdev->dev;
+
+ pm_runtime_forbid(dev);
+ pm_runtime_get_noresume(dev);
+ pm_runtime_dont_use_autosuspend(dev);
+
+}
+
+static int __maybe_unused pt27_gpio_suspend(struct device *dev)
+{
+ struct pt27_gpio *chip = dev_get_drvdata(dev);
+
+ if (pm_runtime_status_suspended(dev)) {
+ dev_dbg(dev, "%s: already runtime-suspended, skipping save\n", __func__);
+ return 0;
+ }
+
+ scoped_guard(raw_spinlock_irqsave, &chip->gen.lock) {
+ pt27_save_regs(chip);
+ iowrite32(0, chip->base + PT27_REG_INT_EN);
+ iowrite32(PT27_GPIO_MASK, chip->base + PT27_REG_INT_MASK);
+ iowrite32(PT27_GPIO_MASK, chip->base + PT27_REG_INT_STAT);
+
+ if (!device_may_wakeup(dev))
+ iowrite16(0, chip->base + PT27_REG_WAKE_EN);
+
+ iowrite16(PT27_WAKE_MASK, chip->base + PT27_REG_WAKE_STAT);
+ }
+
+ synchronize_irq(chip->irq);
+ return 0;
+}
+
+static int __maybe_unused pt27_gpio_resume(struct device *dev)
+{
+ struct pt27_gpio *chip = dev_get_drvdata(dev);
+ unsigned long replay;
+ unsigned int hwirq;
+ u16 wake_status;
+
+ if (pm_runtime_status_suspended(dev))
+ return 0;
+
+ scoped_guard(raw_spinlock_irqsave, &chip->gen.lock) {
+ wake_status = ioread16(chip->base + PT27_REG_WAKE_STAT) & PT27_WAKE_MASK;
+ iowrite16(wake_status, chip->base + PT27_REG_WAKE_STAT);
+ pt27_restore_regs(chip);
+
+ replay = wake_status &
+ ioread32(chip->base + PT27_REG_INT_EN) &
+ ~ioread32(chip->base + PT27_REG_INT_MASK);
+ }
+
+ if (!wake_status)
+ return 0;
+
+ pm_wakeup_event(dev, 0);
+
+ for_each_set_bit(hwirq, &replay, PT27_WAKE_GPIOS)
+ generic_handle_domain_irq_safe(chip->gen.gc.irq.domain, hwirq);
+
+ return 0;
+}
+
+static int __maybe_unused pt27_gpio_runtime_suspend(struct device *dev)
+{
+ struct pt27_gpio *chip = dev_get_drvdata(dev);
+ int ret = 0;
+
+ scoped_guard(raw_spinlock_irqsave, &chip->gen.lock) {
+
+ if (chip->wake_mask && !device_may_wakeup(dev)) {
+ ret = -EBUSY;
+ } else {
+ pt27_save_regs(chip);
+ iowrite32(0, chip->base + PT27_REG_INT_EN);
+ iowrite32(PT27_GPIO_MASK, chip->base + PT27_REG_INT_MASK);
+ iowrite32(PT27_GPIO_MASK, chip->base + PT27_REG_INT_STAT);
+ iowrite16(PT27_WAKE_MASK, chip->base + PT27_REG_WAKE_STAT);
+ }
+ }
+
+ if (ret)
+ return ret;
+
+ synchronize_irq(chip->irq);
+ return 0;
+}
+
+static int __maybe_unused pt27_gpio_runtime_resume(struct device *dev)
+{
+ return pt27_gpio_resume(dev);
+}
+
+static const struct dev_pm_ops pt27_gpio_pm_ops __maybe_unused = {
+ SYSTEM_SLEEP_PM_OPS(pt27_gpio_suspend, pt27_gpio_resume)
+ RUNTIME_PM_OPS(pt27_gpio_runtime_suspend, pt27_gpio_runtime_resume, NULL)
+};
+
+#define PCI_DEVICE_ID_PT27 0x444b
+
+static const struct pci_device_id pt27_gpio_pci_ids[] = {
+ { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_PT27) },
+ { }
+};
+MODULE_DEVICE_TABLE(pci, pt27_gpio_pci_ids);
+
+static struct pci_driver pt27_gpio_pci_driver = {
+ .name = "ptpci-gpio",
+ .id_table = pt27_gpio_pci_ids,
+ .probe = pt27_gpio_probe,
+ .remove = pt27_gpio_remove,
+ .driver = {
+ .pm = pm_ptr(&pt27_gpio_pm_ops),
+ },
+};
+
+module_pci_driver(pt27_gpio_pci_driver);
+
+MODULE_DESCRIPTION("AMD Promontory PCI GPIO Driver");
+MODULE_LICENSE("GPL");
--
2.48.1
^ permalink raw reply [flat|nested] 2+ messages in thread* Re: [PATCH v4] gpio: amdptpci: add support for AMD PT PCI controller
2026-11-16 7:55 [PATCH v4] gpio: amdptpci: add support for AMD PT PCI controller Szuying Chen
@ 2026-11-16 10:03 ` Markus Elfring
0 siblings, 0 replies; 2+ messages in thread
From: Markus Elfring @ 2026-11-16 10:03 UTC (permalink / raw)
To: Szuying Chen, YD Tseng, linux-gpio, Bartosz Golaszewski, Linus Walleij
Cc: LKML, Jesse Chang, Richard Hsu
…
> +++ b/drivers/gpio/gpio-amdptpci.c
> @@ -0,0 +1,634 @@
…
> +module_pci_driver(pt27_gpio_pci_driver);
> +
> +MODULE_DESCRIPTION("AMD Promontory PCI GPIO Driver");
…
Would another macro call “MODULE_AUTHOR” become helpful here?
https://elixir.bootlin.com/linux/v7.4-rc1/source/include/linux/module.h#L233-L236
Regards,
Markus
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2026-11-16 10:04 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-16 7:55 [PATCH v4] gpio: amdptpci: add support for AMD PT PCI controller Szuying Chen
2026-11-16 10:03 ` Markus Elfring
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®