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 38 work_ctx = container_of(work, struct irq_sim_work_ctx, work); 39 handle_simple_irq(irq_to_desc(work_ctx->irq)); 40 } 41 42 /** 43 * irq_sim_init - Initialize the interrupt simulator: allocate a range of 44 * dummy interrupts. 45 * 46 * @sim: The interrupt simulator object to initialize. 47 * @num_irqs: Number of interrupts to allocate 48 * 49 * On success: return the base of the allocated interrupt range. 50 * On failure: a negative errno. 51 */ 52 int irq_sim_init(struct irq_sim *sim, unsigned int num_irqs) 53 { 54 int i; 55 56 sim->irqs = kmalloc_array(num_irqs, sizeof(*sim->irqs), GFP_KERNEL); 57 if (!sim->irqs) 58 return -ENOMEM; 59 60 sim->irq_base = irq_alloc_descs(-1, 0, num_irqs, 0); 61 if (sim->irq_base < 0) { 62 kfree(sim->irqs); 63 return sim->irq_base; 64 } 65 66 for (i = 0; i < num_irqs; i++) { 67 sim->irqs[i].irqnum = sim->irq_base + i; 68 sim->irqs[i].enabled = false; 69 irq_set_chip(sim->irq_base + i, &irq_sim_irqchip); 70 irq_set_chip_data(sim->irq_base + i, &sim->irqs[i]); 71 irq_set_handler(sim->irq_base + i, &handle_simple_irq); 72 irq_modify_status(sim->irq_base + i, 73 IRQ_NOREQUEST | IRQ_NOAUTOEN, IRQ_NOPROBE); 74 } 75 76 init_irq_work(&sim->work_ctx.work, irq_sim_handle_irq); 77 sim->irq_count = num_irqs; 78 79 return sim->irq_base; 80 } 81 EXPORT_SYMBOL_GPL(irq_sim_init); 82 83 /** 84 * irq_sim_fini - Deinitialize the interrupt simulator: free the interrupt 85 * descriptors and allocated memory. 86 * 87 * @sim: The interrupt simulator to tear down. 88 */ 89 void irq_sim_fini(struct irq_sim *sim) 90 { 91 irq_work_sync(&sim->work_ctx.work); 92 irq_free_descs(sim->irq_base, sim->irq_count); 93 kfree(sim->irqs); 94 } 95 EXPORT_SYMBOL_GPL(irq_sim_fini); 96 97 static void devm_irq_sim_release(struct device *dev, void *res) 98 { 99 struct irq_sim_devres *this = res; 100 101 irq_sim_fini(this->sim); 102 } 103 104 /** 105 * irq_sim_init - Initialize the interrupt simulator for a managed device. 106 * 107 * @dev: Device to initialize the simulator object for. 108 * @sim: The interrupt simulator object to initialize. 109 * @num_irqs: Number of interrupts to allocate 110 * 111 * On success: return the base of the allocated interrupt range. 112 * On failure: a negative errno. 113 */ 114 int devm_irq_sim_init(struct device *dev, struct irq_sim *sim, 115 unsigned int num_irqs) 116 { 117 struct irq_sim_devres *dr; 118 int rv; 119 120 dr = devres_alloc(devm_irq_sim_release, sizeof(*dr), GFP_KERNEL); 121 if (!dr) 122 return -ENOMEM; 123 124 rv = irq_sim_init(sim, num_irqs); 125 if (rv < 0) { 126 devres_free(dr); 127 return rv; 128 } 129 130 dr->sim = sim; 131 devres_add(dev, dr); 132 133 return rv; 134 } 135 EXPORT_SYMBOL_GPL(devm_irq_sim_init); 136 137 /** 138 * irq_sim_fire - Enqueue an interrupt. 139 * 140 * @sim: The interrupt simulator object. 141 * @offset: Offset of the simulated interrupt which should be fired. 142 */ 143 void irq_sim_fire(struct irq_sim *sim, unsigned int offset) 144 { 145 if (sim->irqs[offset].enabled) { 146 sim->work_ctx.irq = irq_sim_irqnum(sim, offset); 147 irq_work_queue(&sim->work_ctx.work); 148 } 149 } 150 EXPORT_SYMBOL_GPL(irq_sim_fire); 151 152 /** 153 * irq_sim_irqnum - Get the allocated number of a dummy interrupt. 154 * 155 * @sim: The interrupt simulator object. 156 * @offset: Offset of the simulated interrupt for which to retrieve 157 * the number. 158 */ 159 int irq_sim_irqnum(struct irq_sim *sim, unsigned int offset) 160 { 161 return sim->irqs[offset].irqnum; 162 } 163 EXPORT_SYMBOL_GPL(irq_sim_irqnum); 164