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 mutex_lock(&lock); 96 97 list_for_each_entry(tmp, &producers, node) { 98 if (tmp->token == producer->token) { 99 ret = -EBUSY; 100 goto out_err; 101 } 102 } 103 104 list_for_each_entry(consumer, &consumers, node) { 105 if (consumer->token == producer->token) { 106 ret = __connect(producer, consumer); 107 if (ret) 108 goto out_err; 109 break; 110 } 111 } 112 113 list_add(&producer->node, &producers); 114 115 mutex_unlock(&lock); 116 117 return 0; 118 out_err: 119 mutex_unlock(&lock); 120 return ret; 121 } 122 EXPORT_SYMBOL_GPL(irq_bypass_register_producer); 123 124 /** 125 * irq_bypass_unregister_producer - unregister IRQ bypass producer 126 * @producer: pointer to producer structure 127 * 128 * Remove a previously registered IRQ producer from the list of producers 129 * and disconnect it from any connected IRQ consumer. 130 */ 131 void irq_bypass_unregister_producer(struct irq_bypass_producer *producer) 132 { 133 struct irq_bypass_producer *tmp; 134 struct irq_bypass_consumer *consumer; 135 136 if (!producer->token) 137 return; 138 139 might_sleep(); 140 141 mutex_lock(&lock); 142 143 list_for_each_entry(tmp, &producers, node) { 144 if (tmp->token != producer->token) 145 continue; 146 147 list_for_each_entry(consumer, &consumers, node) { 148 if (consumer->token == producer->token) { 149 __disconnect(producer, consumer); 150 break; 151 } 152 } 153 154 list_del(&producer->node); 155 break; 156 } 157 158 mutex_unlock(&lock); 159 } 160 EXPORT_SYMBOL_GPL(irq_bypass_unregister_producer); 161 162 /** 163 * irq_bypass_register_consumer - register IRQ bypass consumer 164 * @consumer: pointer to consumer structure 165 * 166 * Add the provided IRQ consumer to the list of consumers and connect 167 * with any matching token found on the IRQ producer list. 168 */ 169 int irq_bypass_register_consumer(struct irq_bypass_consumer *consumer) 170 { 171 struct irq_bypass_consumer *tmp; 172 struct irq_bypass_producer *producer; 173 int ret; 174 175 if (!consumer->token || 176 !consumer->add_producer || !consumer->del_producer) 177 return -EINVAL; 178 179 might_sleep(); 180 181 mutex_lock(&lock); 182 183 list_for_each_entry(tmp, &consumers, node) { 184 if (tmp->token == consumer->token || tmp == consumer) { 185 ret = -EBUSY; 186 goto out_err; 187 } 188 } 189 190 list_for_each_entry(producer, &producers, node) { 191 if (producer->token == consumer->token) { 192 ret = __connect(producer, consumer); 193 if (ret) 194 goto out_err; 195 break; 196 } 197 } 198 199 list_add(&consumer->node, &consumers); 200 201 mutex_unlock(&lock); 202 203 return 0; 204 out_err: 205 mutex_unlock(&lock); 206 return ret; 207 } 208 EXPORT_SYMBOL_GPL(irq_bypass_register_consumer); 209 210 /** 211 * irq_bypass_unregister_consumer - unregister IRQ bypass consumer 212 * @consumer: pointer to consumer structure 213 * 214 * Remove a previously registered IRQ consumer from the list of consumers 215 * and disconnect it from any connected IRQ producer. 216 */ 217 void irq_bypass_unregister_consumer(struct irq_bypass_consumer *consumer) 218 { 219 struct irq_bypass_consumer *tmp; 220 struct irq_bypass_producer *producer; 221 222 if (!consumer->token) 223 return; 224 225 might_sleep(); 226 227 mutex_lock(&lock); 228 229 list_for_each_entry(tmp, &consumers, node) { 230 if (tmp != consumer) 231 continue; 232 233 list_for_each_entry(producer, &producers, node) { 234 if (producer->token == consumer->token) { 235 __disconnect(producer, consumer); 236 break; 237 } 238 } 239 240 list_del(&consumer->node); 241 break; 242 } 243 244 mutex_unlock(&lock); 245 } 246 EXPORT_SYMBOL_GPL(irq_bypass_unregister_consumer); 247