1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2017-2018 Bartosz Golaszewski <brgl@bgdev.pl>
6 #include <linux/slab.h>
7 #include <linux/irq_sim.h>
10 struct irq_sim_devres {
14 static void irq_sim_irqmask(struct irq_data *data)
16 struct irq_sim_irq_ctx *irq_ctx = irq_data_get_irq_chip_data(data);
18 irq_ctx->enabled = false;
21 static void irq_sim_irqunmask(struct irq_data *data)
23 struct irq_sim_irq_ctx *irq_ctx = irq_data_get_irq_chip_data(data);
25 irq_ctx->enabled = true;
28 static struct irq_chip irq_sim_irqchip = {
30 .irq_mask = irq_sim_irqmask,
31 .irq_unmask = irq_sim_irqunmask,
34 static void irq_sim_handle_irq(struct irq_work *work)
36 struct irq_sim_work_ctx *work_ctx;
37 unsigned int offset = 0;
41 work_ctx = container_of(work, struct irq_sim_work_ctx, work);
42 sim = container_of(work_ctx, struct irq_sim, work_ctx);
44 while (!bitmap_empty(work_ctx->pending, sim->irq_count)) {
45 offset = find_next_bit(work_ctx->pending,
46 sim->irq_count, offset);
47 clear_bit(offset, work_ctx->pending);
48 irqnum = irq_sim_irqnum(sim, offset);
49 handle_simple_irq(irq_to_desc(irqnum));
54 * irq_sim_init - Initialize the interrupt simulator: allocate a range of
57 * @sim: The interrupt simulator object to initialize.
58 * @num_irqs: Number of interrupts to allocate
60 * On success: return the base of the allocated interrupt range.
61 * On failure: a negative errno.
63 int irq_sim_init(struct irq_sim *sim, unsigned int num_irqs)
67 sim->irqs = kmalloc_array(num_irqs, sizeof(*sim->irqs), GFP_KERNEL);
71 sim->irq_base = irq_alloc_descs(-1, 0, num_irqs, 0);
72 if (sim->irq_base < 0) {
77 sim->work_ctx.pending = bitmap_zalloc(num_irqs, GFP_KERNEL);
78 if (!sim->work_ctx.pending) {
80 irq_free_descs(sim->irq_base, num_irqs);
84 for (i = 0; i < num_irqs; i++) {
85 sim->irqs[i].irqnum = sim->irq_base + i;
86 sim->irqs[i].enabled = false;
87 irq_set_chip(sim->irq_base + i, &irq_sim_irqchip);
88 irq_set_chip_data(sim->irq_base + i, &sim->irqs[i]);
89 irq_set_handler(sim->irq_base + i, &handle_simple_irq);
90 irq_modify_status(sim->irq_base + i,
91 IRQ_NOREQUEST | IRQ_NOAUTOEN, IRQ_NOPROBE);
94 init_irq_work(&sim->work_ctx.work, irq_sim_handle_irq);
95 sim->irq_count = num_irqs;
99 EXPORT_SYMBOL_GPL(irq_sim_init);
102 * irq_sim_fini - Deinitialize the interrupt simulator: free the interrupt
103 * descriptors and allocated memory.
105 * @sim: The interrupt simulator to tear down.
107 void irq_sim_fini(struct irq_sim *sim)
109 irq_work_sync(&sim->work_ctx.work);
110 bitmap_free(sim->work_ctx.pending);
111 irq_free_descs(sim->irq_base, sim->irq_count);
114 EXPORT_SYMBOL_GPL(irq_sim_fini);
116 static void devm_irq_sim_release(struct device *dev, void *res)
118 struct irq_sim_devres *this = res;
120 irq_sim_fini(this->sim);
124 * irq_sim_init - Initialize the interrupt simulator for a managed device.
126 * @dev: Device to initialize the simulator object for.
127 * @sim: The interrupt simulator object to initialize.
128 * @num_irqs: Number of interrupts to allocate
130 * On success: return the base of the allocated interrupt range.
131 * On failure: a negative errno.
133 int devm_irq_sim_init(struct device *dev, struct irq_sim *sim,
134 unsigned int num_irqs)
136 struct irq_sim_devres *dr;
139 dr = devres_alloc(devm_irq_sim_release, sizeof(*dr), GFP_KERNEL);
143 rv = irq_sim_init(sim, num_irqs);
154 EXPORT_SYMBOL_GPL(devm_irq_sim_init);
157 * irq_sim_fire - Enqueue an interrupt.
159 * @sim: The interrupt simulator object.
160 * @offset: Offset of the simulated interrupt which should be fired.
162 void irq_sim_fire(struct irq_sim *sim, unsigned int offset)
164 if (sim->irqs[offset].enabled) {
165 set_bit(offset, sim->work_ctx.pending);
166 irq_work_queue(&sim->work_ctx.work);
169 EXPORT_SYMBOL_GPL(irq_sim_fire);
172 * irq_sim_irqnum - Get the allocated number of a dummy interrupt.
174 * @sim: The interrupt simulator object.
175 * @offset: Offset of the simulated interrupt for which to retrieve
178 int irq_sim_irqnum(struct irq_sim *sim, unsigned int offset)
180 return sim->irqs[offset].irqnum;
182 EXPORT_SYMBOL_GPL(irq_sim_irqnum);