kernel/irq/irq_sim.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2017-2018 Bartosz Golaszewski <brgl@bgdev.pl>
   4  */
   5
   6 #include <linux/slab.h>
   7 #include <linux/irq_sim.h>
   8 #include <linux/irq.h>
   9
  10 struct irq_sim_devres {
  11         struct irq_sim          *sim;
  12 };
  13
  14 static void irq_sim_irqmask(struct irq_data *data)
  15 {
  16         struct irq_sim_irq_ctx *irq_ctx = irq_data_get_irq_chip_data(data);
  17
  18         irq_ctx->enabled = false;
  19 }
  20
  21 static void irq_sim_irqunmask(struct irq_data *data)
  22 {
  23         struct irq_sim_irq_ctx *irq_ctx = irq_data_get_irq_chip_data(data);
  24
  25         irq_ctx->enabled = true;
  26 }
  27
  28 static struct irq_chip irq_sim_irqchip = {
  29         .name           = "irq_sim",
  30         .irq_mask       = irq_sim_irqmask,
  31         .irq_unmask     = irq_sim_irqunmask,
  32 };
  33
  34 static void irq_sim_handle_irq(struct irq_work *work)
  35 {
  36         struct irq_sim_work_ctx *work_ctx;
  37         unsigned int offset = 0;
  38         struct irq_sim *sim;
  39         int irqnum;
  40
  41         work_ctx = container_of(work, struct irq_sim_work_ctx, work);
  42         sim = container_of(work_ctx, struct irq_sim, work_ctx);
  43
  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));
  50         }
  51 }
  52
  53 /**
  54  * irq_sim_init - Initialize the interrupt simulator: allocate a range of
  55  *                dummy interrupts.
  56  *
  57  * @sim:        The interrupt simulator object to initialize.
  58  * @num_irqs:   Number of interrupts to allocate
  59  *
  60  * On success: return the base of the allocated interrupt range.
  61  * On failure: a negative errno.
  62  */
  63 int irq_sim_init(struct irq_sim *sim, unsigned int num_irqs)
  64 {
  65         int i;
  66
  67         sim->irqs = kmalloc_array(num_irqs, sizeof(*sim->irqs), GFP_KERNEL);
  68         if (!sim->irqs)
  69                 return -ENOMEM;
  70
  71         sim->irq_base = irq_alloc_descs(-1, 0, num_irqs, 0);
  72         if (sim->irq_base < 0) {
  73                 kfree(sim->irqs);
  74                 return sim->irq_base;
  75         }
  76
  77         sim->work_ctx.pending = bitmap_zalloc(num_irqs, GFP_KERNEL);
  78         if (!sim->work_ctx.pending) {
  79                 kfree(sim->irqs);
  80                 irq_free_descs(sim->irq_base, num_irqs);
  81                 return -ENOMEM;
  82         }
  83
  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);
  92         }
  93
  94         init_irq_work(&sim->work_ctx.work, irq_sim_handle_irq);
  95         sim->irq_count = num_irqs;
  96
  97         return sim->irq_base;
  98 }
  99 EXPORT_SYMBOL_GPL(irq_sim_init);
 100
 101 /**
 102  * irq_sim_fini - Deinitialize the interrupt simulator: free the interrupt
 103  *                descriptors and allocated memory.
 104  *
 105  * @sim:        The interrupt simulator to tear down.
 106  */
 107 void irq_sim_fini(struct irq_sim *sim)
 108 {
 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);
 112         kfree(sim->irqs);
 113 }
 114 EXPORT_SYMBOL_GPL(irq_sim_fini);
 115
 116 static void devm_irq_sim_release(struct device *dev, void *res)
 117 {
 118         struct irq_sim_devres *this = res;
 119
 120         irq_sim_fini(this->sim);
 121 }
 122
 123 /**
 124  * irq_sim_init - Initialize the interrupt simulator for a managed device.
 125  *
 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
 129  *
 130  * On success: return the base of the allocated interrupt range.
 131  * On failure: a negative errno.
 132  */
 133 int devm_irq_sim_init(struct device *dev, struct irq_sim *sim,
 134                       unsigned int num_irqs)
 135 {
 136         struct irq_sim_devres *dr;
 137         int rv;
 138
 139         dr = devres_alloc(devm_irq_sim_release, sizeof(*dr), GFP_KERNEL);
 140         if (!dr)
 141                 return -ENOMEM;
 142
 143         rv = irq_sim_init(sim, num_irqs);
 144         if (rv < 0) {
 145                 devres_free(dr);
 146                 return rv;
 147         }
 148
 149         dr->sim = sim;
 150         devres_add(dev, dr);
 151
 152         return rv;
 153 }
 154 EXPORT_SYMBOL_GPL(devm_irq_sim_init);
 155
 156 /**
 157  * irq_sim_fire - Enqueue an interrupt.
 158  *
 159  * @sim:        The interrupt simulator object.
 160  * @offset:     Offset of the simulated interrupt which should be fired.
 161  */
 162 void irq_sim_fire(struct irq_sim *sim, unsigned int offset)
 163 {
 164         if (sim->irqs[offset].enabled) {
 165                 set_bit(offset, sim->work_ctx.pending);
 166                 irq_work_queue(&sim->work_ctx.work);
 167         }
 168 }
 169 EXPORT_SYMBOL_GPL(irq_sim_fire);
 170
 171 /**
 172  * irq_sim_irqnum - Get the allocated number of a dummy interrupt.
 173  *
 174  * @sim:        The interrupt simulator object.
 175  * @offset:     Offset of the simulated interrupt for which to retrieve
 176  *              the number.
 177  */
 178 int irq_sim_irqnum(struct irq_sim *sim, unsigned int offset)
 179 {
 180         return sim->irqs[offset].irqnum;
 181 }
 182 EXPORT_SYMBOL_GPL(irq_sim_irqnum);