[linux.git] / include / linux / irqbypass.h

/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * IRQ offload/bypass manager
 *
 * Copyright (C) 2015 Red Hat, Inc.
 * Copyright (c) 2015 Linaro Ltd.
 */
#ifndef IRQBYPASS_H
#define IRQBYPASS_H

#include <linux/list.h>

struct irq_bypass_consumer;

/*
 * Theory of operation
 *
 * The IRQ bypass manager is a simple set of lists and callbacks that allows
 * IRQ producers (ex. physical interrupt sources) to be matched to IRQ
 * consumers (ex. virtualization hardware that allows IRQ bypass or offload)
 * via a shared token (ex. eventfd_ctx).  Producers and consumers register
 * independently.  When a token match is found, the optional @stop callback
 * will be called for each participant.  The pair will then be connected via
 * the @add_* callbacks, and finally the optional @start callback will allow
 * any final coordination.  When either participant is unregistered, the
 * process is repeated using the @del_* callbacks in place of the @add_*
 * callbacks.  Match tokens must be unique per producer/consumer, 1:N pairings
 * are not supported.
 */

/**
 * struct irq_bypass_producer - IRQ bypass producer definition
 * @node: IRQ bypass manager private list management
 * @token: opaque token to match between producer and consumer (non-NULL)
 * @irq: Linux IRQ number for the producer device
 * @add_consumer: Connect the IRQ producer to an IRQ consumer (optional)
 * @del_consumer: Disconnect the IRQ producer from an IRQ consumer (optional)
 * @stop: Perform any quiesce operations necessary prior to add/del (optional)
 * @start: Perform any startup operations necessary after add/del (optional)
 *
 * The IRQ bypass producer structure represents an interrupt source for
 * participation in possible host bypass, for instance an interrupt vector
 * for a physical device assigned to a VM.
 */
struct irq_bypass_producer {
	struct list_head node;
	void *token;
	int irq;
	int (*add_consumer)(struct irq_bypass_producer *,
			    struct irq_bypass_consumer *);
	void (*del_consumer)(struct irq_bypass_producer *,
			     struct irq_bypass_consumer *);
	void (*stop)(struct irq_bypass_producer *);
	void (*start)(struct irq_bypass_producer *);
};

/**
 * struct irq_bypass_consumer - IRQ bypass consumer definition
 * @node: IRQ bypass manager private list management
 * @token: opaque token to match between producer and consumer (non-NULL)
 * @add_producer: Connect the IRQ consumer to an IRQ producer
 * @del_producer: Disconnect the IRQ consumer from an IRQ producer
 * @stop: Perform any quiesce operations necessary prior to add/del (optional)
 * @start: Perform any startup operations necessary after add/del (optional)
 *
 * The IRQ bypass consumer structure represents an interrupt sink for
 * participation in possible host bypass, for instance a hypervisor may
 * support offloads to allow bypassing the host entirely or offload
 * portions of the interrupt handling to the VM.
 */
struct irq_bypass_consumer {
	struct list_head node;
	void *token;
	int (*add_producer)(struct irq_bypass_consumer *,
			    struct irq_bypass_producer *);
	void (*del_producer)(struct irq_bypass_consumer *,
			     struct irq_bypass_producer *);
	void (*stop)(struct irq_bypass_consumer *);
	void (*start)(struct irq_bypass_consumer *);
};

int irq_bypass_register_producer(struct irq_bypass_producer *);
void irq_bypass_unregister_producer(struct irq_bypass_producer *);
int irq_bypass_register_consumer(struct irq_bypass_consumer *);
void irq_bypass_unregister_consumer(struct irq_bypass_consumer *);

#endif /* IRQBYPASS_H */
Commit	Line	Data
d2912cb1	1	/* SPDX-License-Identifier: GPL-2.0-only */
f73f8173 AW	2	/*
	3	* IRQ offload/bypass manager
	4	*
	5	* Copyright (C) 2015 Red Hat, Inc.
	6	* Copyright (c) 2015 Linaro Ltd.
f73f8173 AW	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
b52f3ed0	34	* @token: opaque token to match between producer and consumer (non-NULL)
f73f8173 AW	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
b52f3ed0	60	* @token: opaque token to match between producer and consumer (non-NULL)
f73f8173 AW	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 */