1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * IRQ offload/bypass manager 4 * 5 * Copyright (C) 2015 Red Hat, Inc. 6 * Copyright (c) 2015 Linaro Ltd. 7 * 8 * Various virtualization hardware acceleration techniques allow bypassing or 9 * offloading interrupts received from devices around the host kernel. Posted 10 * Interrupts on Intel VT-d systems can allow interrupts to be received 11 * directly by a virtual machine. ARM IRQ Forwarding allows forwarded physical 12 * interrupts to be directly deactivated by the guest. This manager allows 13 * interrupt producers and consumers to find each other to enable this sort of 14 * bypass. 15 */ 16 17 #include <linux/irqbypass.h> 18 #include <linux/list.h> 19 #include <linux/module.h> 20 #include <linux/mutex.h> 21 22 MODULE_LICENSE("GPL v2"); 23 MODULE_DESCRIPTION("IRQ bypass manager utility module"); 24 25 static LIST_HEAD(producers); 26 static LIST_HEAD(consumers); 27 static DEFINE_MUTEX(lock); 28 29 /* @lock must be held when calling connect */ 30 static int __connect(struct irq_bypass_producer *prod, 31 struct irq_bypass_consumer *cons) 32 { 33 int ret = 0; 34 35 if (prod->stop) 36 prod->stop(prod); 37 if (cons->stop) 38 cons->stop(cons); 39 40 if (prod->add_consumer) 41 ret = prod->add_consumer(prod, cons); 42 43 if (!ret) { 44 ret = cons->add_producer(cons, prod); 45 if (ret && prod->del_consumer) 46 prod->del_consumer(prod, cons); 47 } 48 49 if (cons->start) 50 cons->start(cons); 51 if (prod->start) 52 prod->start(prod); 53 54 return ret; 55 } 56 57 /* @lock must be held when calling disconnect */ 58 static void __disconnect(struct irq_bypass_producer *prod, 59 struct irq_bypass_consumer *cons) 60 { 61 if (prod->stop) 62 prod->stop(prod); 63 if (cons->stop) 64 cons->stop(cons); 65 66 cons->del_producer(cons, prod); 67 68 if (prod->del_consumer) 69 prod->del_consumer(prod, cons); 70 71 if (cons->start) 72 cons->start(cons); 73 if (prod->start) 74 prod->start(prod); 75 } 76 77 /** 78 * irq_bypass_register_producer - register IRQ bypass producer 79 * @producer: pointer to producer structure 80 * 81 * Add the provided IRQ producer to the list of producers and connect 82 * with any matching token found on the IRQ consumers list. 83 */ 84 int irq_bypass_register_producer(struct irq_bypass_producer *producer) 85 { 86 struct irq_bypass_producer *tmp; 87 struct irq_bypass_consumer *consumer; 88 int ret; 89 90 if (!producer->token) 91 return -EINVAL; 92 93 might_sleep(); 94 95 if (!try_module_get(THIS_MODULE)) 96 return -ENODEV; 97 98 mutex_lock(&lock); 99 100 list_for_each_entry(tmp, &producers, node) { 101 if (tmp->token == producer->token) { 102 ret = -EBUSY; 103 goto out_err; 104 } 105 } 106 107 list_for_each_entry(consumer, &consumers, node) { 108 if (consumer->token == producer->token) { 109 ret = __connect(producer, consumer); 110 if (ret) 111 goto out_err; 112 break; 113 } 114 } 115 116 list_add(&producer->node, &producers); 117 118 mutex_unlock(&lock); 119 120 return 0; 121 out_err: 122 mutex_unlock(&lock); 123 module_put(THIS_MODULE); 124 return ret; 125 } 126 EXPORT_SYMBOL_GPL(irq_bypass_register_producer); 127 128 /** 129 * irq_bypass_unregister_producer - unregister IRQ bypass producer 130 * @producer: pointer to producer structure 131 * 132 * Remove a previously registered IRQ producer from the list of producers 133 * and disconnect it from any connected IRQ consumer. 134 */ 135 void irq_bypass_unregister_producer(struct irq_bypass_producer *producer) 136 { 137 struct irq_bypass_producer *tmp; 138 struct irq_bypass_consumer *consumer; 139 140 if (!producer->token) 141 return; 142 143 might_sleep(); 144 145 if (!try_module_get(THIS_MODULE)) 146 return; /* nothing in the list anyway */ 147 148 mutex_lock(&lock); 149 150 list_for_each_entry(tmp, &producers, node) { 151 if (tmp->token != producer->token) 152 continue; 153 154 list_for_each_entry(consumer, &consumers, node) { 155 if (consumer->token == producer->token) { 156 __disconnect(producer, consumer); 157 break; 158 } 159 } 160 161 list_del(&producer->node); 162 module_put(THIS_MODULE); 163 break; 164 } 165 166 mutex_unlock(&lock); 167 168 module_put(THIS_MODULE); 169 } 170 EXPORT_SYMBOL_GPL(irq_bypass_unregister_producer); 171 172 /** 173 * irq_bypass_register_consumer - register IRQ bypass consumer 174 * @consumer: pointer to consumer structure 175 * 176 * Add the provided IRQ consumer to the list of consumers and connect 177 * with any matching token found on the IRQ producer list. 178 */ 179 int irq_bypass_register_consumer(struct irq_bypass_consumer *consumer) 180 { 181 struct irq_bypass_consumer *tmp; 182 struct irq_bypass_producer *producer; 183 int ret; 184 185 if (!consumer->token || 186 !consumer->add_producer || !consumer->del_producer) 187 return -EINVAL; 188 189 might_sleep(); 190 191 if (!try_module_get(THIS_MODULE)) 192 return -ENODEV; 193 194 mutex_lock(&lock); 195 196 list_for_each_entry(tmp, &consumers, node) { 197 if (tmp->token == consumer->token || tmp == consumer) { 198 ret = -EBUSY; 199 goto out_err; 200 } 201 } 202 203 list_for_each_entry(producer, &producers, node) { 204 if (producer->token == consumer->token) { 205 ret = __connect(producer, consumer); 206 if (ret) 207 goto out_err; 208 break; 209 } 210 } 211 212 list_add(&consumer->node, &consumers); 213 214 mutex_unlock(&lock); 215 216 return 0; 217 out_err: 218 mutex_unlock(&lock); 219 module_put(THIS_MODULE); 220 return ret; 221 } 222 EXPORT_SYMBOL_GPL(irq_bypass_register_consumer); 223 224 /** 225 * irq_bypass_unregister_consumer - unregister IRQ bypass consumer 226 * @consumer: pointer to consumer structure 227 * 228 * Remove a previously registered IRQ consumer from the list of consumers 229 * and disconnect it from any connected IRQ producer. 230 */ 231 void irq_bypass_unregister_consumer(struct irq_bypass_consumer *consumer) 232 { 233 struct irq_bypass_consumer *tmp; 234 struct irq_bypass_producer *producer; 235 236 if (!consumer->token) 237 return; 238 239 might_sleep(); 240 241 if (!try_module_get(THIS_MODULE)) 242 return; /* nothing in the list anyway */ 243 244 mutex_lock(&lock); 245 246 list_for_each_entry(tmp, &consumers, node) { 247 if (tmp != consumer) 248 continue; 249 250 list_for_each_entry(producer, &producers, node) { 251 if (producer->token == consumer->token) { 252 __disconnect(producer, consumer); 253 break; 254 } 255 } 256 257 list_del(&consumer->node); 258 module_put(THIS_MODULE); 259 break; 260 } 261 262 mutex_unlock(&lock); 263 264 module_put(THIS_MODULE); 265 } 266 EXPORT_SYMBOL_GPL(irq_bypass_unregister_consumer); 267