1/*
 2 * This program is free software; you can redistribute it and/or modify
 3 * it under the terms of the GNU General Public License as published by
 4 * the Free Software Foundation; either version 2 of the License.
 5 *
 6 * This program is distributed in the hope that it will be useful,
 7 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 9 * GNU General Public License for more details.
10 *
11 * You should have received a copy of the GNU General Public License
12 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
13 */
14
15#ifndef __KVM_IODEV_H__
16#define __KVM_IODEV_H__
17
18#include <linux/kvm_types.h>
19#include <linux/errno.h>
20
21struct kvm_io_device;
22struct kvm_vcpu;
23
24/**
25 * kvm_io_device_ops are called under kvm slots_lock.
26 * read and write handlers return 0 if the transaction has been handled,
27 * or non-zero to have it passed to the next device.
28 **/
29struct kvm_io_device_ops {
30	int (*read)(struct kvm_vcpu *vcpu,
31		    struct kvm_io_device *this,
32		    gpa_t addr,
33		    int len,
34		    void *val);
35	int (*write)(struct kvm_vcpu *vcpu,
36		     struct kvm_io_device *this,
37		     gpa_t addr,
38		     int len,
39		     const void *val);
40	void (*destructor)(struct kvm_io_device *this);
41};
42
43
44struct kvm_io_device {
45	const struct kvm_io_device_ops *ops;
46};
47
48static inline void kvm_iodevice_init(struct kvm_io_device *dev,
49				     const struct kvm_io_device_ops *ops)
50{
51	dev->ops = ops;
52}
53
54static inline int kvm_iodevice_read(struct kvm_vcpu *vcpu,
55				    struct kvm_io_device *dev, gpa_t addr,
56				    int l, void *v)
57{
58	return dev->ops->read ? dev->ops->read(vcpu, dev, addr, l, v)
59				: -EOPNOTSUPP;
60}
61
62static inline int kvm_iodevice_write(struct kvm_vcpu *vcpu,
63				     struct kvm_io_device *dev, gpa_t addr,
64				     int l, const void *v)
65{
66	return dev->ops->write ? dev->ops->write(vcpu, dev, addr, l, v)
67				 : -EOPNOTSUPP;
68}
69
70static inline void kvm_iodevice_destructor(struct kvm_io_device *dev)
71{
72	if (dev->ops->destructor)
73		dev->ops->destructor(dev);
74}
75
76#endif /* __KVM_IODEV_H__ */

 1/* SPDX-License-Identifier: GPL-2.0-only */
 
 
 
 
 
 
 
 
 
 
 
 
 2
 3#ifndef __KVM_IODEV_H__
 4#define __KVM_IODEV_H__
 5
 6#include <linux/kvm_types.h>
 7#include <linux/errno.h>
 8
 9struct kvm_io_device;
10struct kvm_vcpu;
11
12/**
13 * kvm_io_device_ops are called under kvm slots_lock.
14 * read and write handlers return 0 if the transaction has been handled,
15 * or non-zero to have it passed to the next device.
16 **/
17struct kvm_io_device_ops {
18	int (*read)(struct kvm_vcpu *vcpu,
19		    struct kvm_io_device *this,
20		    gpa_t addr,
21		    int len,
22		    void *val);
23	int (*write)(struct kvm_vcpu *vcpu,
24		     struct kvm_io_device *this,
25		     gpa_t addr,
26		     int len,
27		     const void *val);
28	void (*destructor)(struct kvm_io_device *this);
29};
30
31
32struct kvm_io_device {
33	const struct kvm_io_device_ops *ops;
34};
35
36static inline void kvm_iodevice_init(struct kvm_io_device *dev,
37				     const struct kvm_io_device_ops *ops)
38{
39	dev->ops = ops;
40}
41
42static inline int kvm_iodevice_read(struct kvm_vcpu *vcpu,
43				    struct kvm_io_device *dev, gpa_t addr,
44				    int l, void *v)
45{
46	return dev->ops->read ? dev->ops->read(vcpu, dev, addr, l, v)
47				: -EOPNOTSUPP;
48}
49
50static inline int kvm_iodevice_write(struct kvm_vcpu *vcpu,
51				     struct kvm_io_device *dev, gpa_t addr,
52				     int l, const void *v)
53{
54	return dev->ops->write ? dev->ops->write(vcpu, dev, addr, l, v)
55				 : -EOPNOTSUPP;
56}
57
58static inline void kvm_iodevice_destructor(struct kvm_io_device *dev)
59{
60	if (dev->ops->destructor)
61		dev->ops->destructor(dev);
62}
63
64#endif /* __KVM_IODEV_H__ */