Merge branch 'irq/for-gpio' into irq/core

Merge the irq simulator which is in a separate branch so it can be consumed
by the gpio folks.

5 files changed, 215 insertions, 0 deletions

diff --git a/Documentation/driver-model/devres.txt b/Documentation/driver-model/devres.txt
index 30e04f7a690d..69f08c0f23a8 100644
--- a/Documentation/driver-model/devres.txt
+++ b/Documentation/driver-model/devres.txt
@@ -312,6 +312,7 @@ IRQ
   devm_irq_alloc_descs_from()
   devm_irq_alloc_generic_chip()
   devm_irq_setup_generic_chip()
+  devm_irq_sim_init()
 
 LED
   devm_led_classdev_register()
diff --git a/include/linux/irq_sim.h b/include/linux/irq_sim.h
new file mode 100644
index 000000000000..0380d899b955
--- /dev/null
+++ b/include/linux/irq_sim.h
@@ -0,0 +1,44 @@
+#ifndef _LINUX_IRQ_SIM_H
+#define _LINUX_IRQ_SIM_H
+/*
+ * Copyright (C) 2017 Bartosz Golaszewski <brgl@bgdev.pl>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/irq_work.h>
+#include <linux/device.h>
+
+/*
+ * Provides a framework for allocating simulated interrupts which can be
+ * requested like normal irqs and enqueued from process context.
+ */
+
+struct irq_sim_work_ctx {
+        struct irq_work         work;
+        int                     irq;
+};
+
+struct irq_sim_irq_ctx {
+        int                     irqnum;
+        bool                    enabled;
+};
+
+struct irq_sim {
+        struct irq_sim_work_ctx work_ctx;
+        int                     irq_base;
+        unsigned int            irq_count;
+        struct irq_sim_irq_ctx  *irqs;
+};
+
+int irq_sim_init(struct irq_sim *sim, unsigned int num_irqs);
+int devm_irq_sim_init(struct device *dev, struct irq_sim *sim,
+                      unsigned int num_irqs);
+void irq_sim_fini(struct irq_sim *sim);
+void irq_sim_fire(struct irq_sim *sim, unsigned int offset);
+int irq_sim_irqnum(struct irq_sim *sim, unsigned int offset);
+
+#endif /* _LINUX_IRQ_SIM_H */
diff --git a/kernel/irq/Kconfig b/kernel/irq/Kconfig
index 27c4e774071c..1d06af787932 100644
--- a/kernel/irq/Kconfig
+++ b/kernel/irq/Kconfig
@@ -63,6 +63,11 @@ config GENERIC_IRQ_CHIP
 config IRQ_DOMAIN
         bool
 
+# Support for simulated interrupts
+config IRQ_SIM
+        bool
+        select IRQ_WORK
+
 # Support for hierarchical irq domains
 config IRQ_DOMAIN_HIERARCHY
         bool
diff --git a/kernel/irq/Makefile b/kernel/irq/Makefile
index e4aef7351f2b..1970cafe8f2a 100644
--- a/kernel/irq/Makefile
+++ b/kernel/irq/Makefile
@@ -4,6 +4,7 @@ obj-$(CONFIG_IRQ_TIMINGS) += timings.o
 obj-$(CONFIG_GENERIC_IRQ_CHIP) += generic-chip.o
 obj-$(CONFIG_GENERIC_IRQ_PROBE) += autoprobe.o
 obj-$(CONFIG_IRQ_DOMAIN) += irqdomain.o
+obj-$(CONFIG_IRQ_SIM) += irq_sim.o
 obj-$(CONFIG_PROC_FS) += proc.o
 obj-$(CONFIG_GENERIC_PENDING_IRQ) += migration.o
 obj-$(CONFIG_GENERIC_IRQ_MIGRATION) += cpuhotplug.o
diff --git a/kernel/irq/irq_sim.c b/kernel/irq/irq_sim.c
new file mode 100644
index 000000000000..24caabf1a0f7
--- /dev/null
+++ b/kernel/irq/irq_sim.c
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2017 Bartosz Golaszewski <brgl@bgdev.pl>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/irq_sim.h>
+#include <linux/irq.h>
+
+struct irq_sim_devres {
+        struct irq_sim          *sim;
+};
+
+static void irq_sim_irqmask(struct irq_data *data)
+{
+        struct irq_sim_irq_ctx *irq_ctx = irq_data_get_irq_chip_data(data);
+
+        irq_ctx->enabled = false;
+}
+
+static void irq_sim_irqunmask(struct irq_data *data)
+{
+        struct irq_sim_irq_ctx *irq_ctx = irq_data_get_irq_chip_data(data);
+
+        irq_ctx->enabled = true;
+}
+
+static struct irq_chip irq_sim_irqchip = {
+        .name           = "irq_sim",
+        .irq_mask       = irq_sim_irqmask,
+        .irq_unmask     = irq_sim_irqunmask,
+};
+
+static void irq_sim_handle_irq(struct irq_work *work)
+{
+        struct irq_sim_work_ctx *work_ctx;
+
+        work_ctx = container_of(work, struct irq_sim_work_ctx, work);
+        handle_simple_irq(irq_to_desc(work_ctx->irq));
+}
+
+/**
+ * irq_sim_init - Initialize the interrupt simulator: allocate a range of
+ *                dummy interrupts.
+ *
+ * @sim:        The interrupt simulator object to initialize.
+ * @num_irqs:   Number of interrupts to allocate
+ *
+ * Returns 0 on success and a negative error number on failure.
+ */
+int irq_sim_init(struct irq_sim *sim, unsigned int num_irqs)
+{
+        int i;
+
+        sim->irqs = kmalloc_array(num_irqs, sizeof(*sim->irqs), GFP_KERNEL);
+        if (!sim->irqs)
+                return -ENOMEM;
+
+        sim->irq_base = irq_alloc_descs(-1, 0, num_irqs, 0);
+        if (sim->irq_base < 0) {
+                kfree(sim->irqs);
+                return sim->irq_base;
+        }
+
+        for (i = 0; i < num_irqs; i++) {
+                sim->irqs[i].irqnum = sim->irq_base + i;
+                sim->irqs[i].enabled = false;
+                irq_set_chip(sim->irq_base + i, &irq_sim_irqchip);
+                irq_set_chip_data(sim->irq_base + i, &sim->irqs[i]);
+                irq_set_handler(sim->irq_base + i, &handle_simple_irq);
+                irq_modify_status(sim->irq_base + i,
+                                  IRQ_NOREQUEST | IRQ_NOAUTOEN, IRQ_NOPROBE);
+        }
+
+        init_irq_work(&sim->work_ctx.work, irq_sim_handle_irq);
+        sim->irq_count = num_irqs;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(irq_sim_init);
+
+/**
+ * irq_sim_fini - Deinitialize the interrupt simulator: free the interrupt
+ *                descriptors and allocated memory.
+ *
+ * @sim:        The interrupt simulator to tear down.
+ */
+void irq_sim_fini(struct irq_sim *sim)
+{
+        irq_work_sync(&sim->work_ctx.work);
+        irq_free_descs(sim->irq_base, sim->irq_count);
+        kfree(sim->irqs);
+}
+EXPORT_SYMBOL_GPL(irq_sim_fini);
+
+static void devm_irq_sim_release(struct device *dev, void *res)
+{
+        struct irq_sim_devres *this = res;
+
+        irq_sim_fini(this->sim);
+}
+
+/**
+ * irq_sim_init - Initialize the interrupt simulator for a managed device.
+ *
+ * @dev:        Device to initialize the simulator object for.
+ * @sim:        The interrupt simulator object to initialize.
+ * @num_irqs:   Number of interrupts to allocate
+ *
+ * Returns 0 on success and a negative error number on failure.
+ */
+int devm_irq_sim_init(struct device *dev, struct irq_sim *sim,
+                      unsigned int num_irqs)
+{
+        struct irq_sim_devres *dr;
+        int rv;
+
+        dr = devres_alloc(devm_irq_sim_release, sizeof(*dr), GFP_KERNEL);
+        if (!dr)
+                return -ENOMEM;
+
+        rv = irq_sim_init(sim, num_irqs);
+        if (rv) {
+                devres_free(dr);
+                return rv;
+        }
+
+        dr->sim = sim;
+        devres_add(dev, dr);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(devm_irq_sim_init);
+
+/**
+ * irq_sim_fire - Enqueue an interrupt.
+ *
+ * @sim:        The interrupt simulator object.
+ * @offset:     Offset of the simulated interrupt which should be fired.
+ */
+void irq_sim_fire(struct irq_sim *sim, unsigned int offset)
+{
+        if (sim->irqs[offset].enabled) {
+                sim->work_ctx.irq = irq_sim_irqnum(sim, offset);
+                irq_work_queue(&sim->work_ctx.work);
+        }
+}
+EXPORT_SYMBOL_GPL(irq_sim_fire);
+
+/**
+ * irq_sim_irqnum - Get the allocated number of a dummy interrupt.
+ *
+ * @sim:        The interrupt simulator object.
+ * @offset:     Offset of the simulated interrupt for which to retrieve
+ *              the number.
+ */
+int irq_sim_irqnum(struct irq_sim *sim, unsigned int offset)
+{
+        return sim->irqs[offset].irqnum;
+}
+EXPORT_SYMBOL_GPL(irq_sim_irqnum);