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 #ifndef IRQBYPASS_H 9 #define IRQBYPASS_H 10 11 #include <linux/list.h> 12 13 struct irq_bypass_consumer; 14 15 /* 16 * Theory of operation 17 * 18 * The IRQ bypass manager is a simple set of lists and callbacks that allows 19 * IRQ producers (ex. physical interrupt sources) to be matched to IRQ 20 * consumers (ex. virtualization hardware that allows IRQ bypass or offload) 21 * via a shared token (ex. eventfd_ctx). Producers and consumers register 22 * independently. When a token match is found, the optional @stop callback 23 * will be called for each participant. The pair will then be connected via 24 * the @add_* callbacks, and finally the optional @start callback will allow 25 * any final coordination. When either participant is unregistered, the 26 * process is repeated using the @del_* callbacks in place of the @add_* 27 * callbacks. Match tokens must be unique per producer/consumer, 1:N pairings 28 * are not supported. 29 */ 30 31 /** 32 * struct irq_bypass_producer - IRQ bypass producer definition 33 * @node: IRQ bypass manager private list management 34 * @token: opaque token to match between producer and consumer (non-NULL) 35 * @irq: Linux IRQ number for the producer device 36 * @add_consumer: Connect the IRQ producer to an IRQ consumer (optional) 37 * @del_consumer: Disconnect the IRQ producer from an IRQ consumer (optional) 38 * @stop: Perform any quiesce operations necessary prior to add/del (optional) 39 * @start: Perform any startup operations necessary after add/del (optional) 40 * 41 * The IRQ bypass producer structure represents an interrupt source for 42 * participation in possible host bypass, for instance an interrupt vector 43 * for a physical device assigned to a VM. 44 */ 45 struct irq_bypass_producer { 46 struct list_head node; 47 void *token; 48 int irq; 49 int (*add_consumer)(struct irq_bypass_producer *, 50 struct irq_bypass_consumer *); 51 void (*del_consumer)(struct irq_bypass_producer *, 52 struct irq_bypass_consumer *); 53 void (*stop)(struct irq_bypass_producer *); 54 void (*start)(struct irq_bypass_producer *); 55 }; 56 57 /** 58 * struct irq_bypass_consumer - IRQ bypass consumer definition 59 * @node: IRQ bypass manager private list management 60 * @token: opaque token to match between producer and consumer (non-NULL) 61 * @add_producer: Connect the IRQ consumer to an IRQ producer 62 * @del_producer: Disconnect the IRQ consumer from an IRQ producer 63 * @stop: Perform any quiesce operations necessary prior to add/del (optional) 64 * @start: Perform any startup operations necessary after add/del (optional) 65 * 66 * The IRQ bypass consumer structure represents an interrupt sink for 67 * participation in possible host bypass, for instance a hypervisor may 68 * support offloads to allow bypassing the host entirely or offload 69 * portions of the interrupt handling to the VM. 70 */ 71 struct irq_bypass_consumer { 72 struct list_head node; 73 void *token; 74 int (*add_producer)(struct irq_bypass_consumer *, 75 struct irq_bypass_producer *); 76 void (*del_producer)(struct irq_bypass_consumer *, 77 struct irq_bypass_producer *); 78 void (*stop)(struct irq_bypass_consumer *); 79 void (*start)(struct irq_bypass_consumer *); 80 }; 81 82 int irq_bypass_register_producer(struct irq_bypass_producer *); 83 void irq_bypass_unregister_producer(struct irq_bypass_producer *); 84 int irq_bypass_register_consumer(struct irq_bypass_consumer *); 85 void irq_bypass_unregister_consumer(struct irq_bypass_consumer *); 86 87 #endif /* IRQBYPASS_H */ 88