1
2
3
4
5
6
7
8
9#include "qemu/osdep.h"
10#include "qapi/error.h"
11#include "hw/qdev-properties.h"
12#include "hw/virtio/virtio-bus.h"
13#include "hw/virtio/vhost-user-i2c.h"
14#include "qemu/error-report.h"
15#include "standard-headers/linux/virtio_ids.h"
16
17static const int feature_bits[] = {
18 VIRTIO_I2C_F_ZERO_LENGTH_REQUEST,
19 VIRTIO_F_RING_RESET,
20 VHOST_INVALID_FEATURE_BIT
21};
22
23static void vu_i2c_start(VirtIODevice *vdev)
24{
25 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
26 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
27 VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
28 int ret, i;
29
30 if (!k->set_guest_notifiers) {
31 error_report("binding does not support guest notifiers");
32 return;
33 }
34
35 ret = vhost_dev_enable_notifiers(&i2c->vhost_dev, vdev);
36 if (ret < 0) {
37 error_report("Error enabling host notifiers: %d", -ret);
38 return;
39 }
40
41 ret = k->set_guest_notifiers(qbus->parent, i2c->vhost_dev.nvqs, true);
42 if (ret < 0) {
43 error_report("Error binding guest notifier: %d", -ret);
44 goto err_host_notifiers;
45 }
46
47 i2c->vhost_dev.acked_features = vdev->guest_features;
48
49 ret = vhost_dev_start(&i2c->vhost_dev, vdev, true);
50 if (ret < 0) {
51 error_report("Error starting vhost-user-i2c: %d", -ret);
52 goto err_guest_notifiers;
53 }
54
55
56
57
58
59
60 for (i = 0; i < i2c->vhost_dev.nvqs; i++) {
61 vhost_virtqueue_mask(&i2c->vhost_dev, vdev, i, false);
62 }
63
64 return;
65
66err_guest_notifiers:
67 k->set_guest_notifiers(qbus->parent, i2c->vhost_dev.nvqs, false);
68err_host_notifiers:
69 vhost_dev_disable_notifiers(&i2c->vhost_dev, vdev);
70}
71
72static void vu_i2c_stop(VirtIODevice *vdev)
73{
74 VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
75 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
76 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
77 int ret;
78
79 if (!k->set_guest_notifiers) {
80 return;
81 }
82
83 vhost_dev_stop(&i2c->vhost_dev, vdev, true);
84
85 ret = k->set_guest_notifiers(qbus->parent, i2c->vhost_dev.nvqs, false);
86 if (ret < 0) {
87 error_report("vhost guest notifier cleanup failed: %d", ret);
88 return;
89 }
90
91 vhost_dev_disable_notifiers(&i2c->vhost_dev, vdev);
92}
93
94static void vu_i2c_set_status(VirtIODevice *vdev, uint8_t status)
95{
96 VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
97 bool should_start = virtio_device_should_start(vdev, status);
98
99 if (vhost_dev_is_started(&i2c->vhost_dev) == should_start) {
100 return;
101 }
102
103 if (should_start) {
104 vu_i2c_start(vdev);
105 } else {
106 vu_i2c_stop(vdev);
107 }
108}
109
110static uint64_t vu_i2c_get_features(VirtIODevice *vdev,
111 uint64_t requested_features, Error **errp)
112{
113 VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
114
115 virtio_add_feature(&requested_features, VIRTIO_I2C_F_ZERO_LENGTH_REQUEST);
116 return vhost_get_features(&i2c->vhost_dev, feature_bits, requested_features);
117}
118
119static void vu_i2c_handle_output(VirtIODevice *vdev, VirtQueue *vq)
120{
121
122
123
124
125}
126
127static void vu_i2c_guest_notifier_mask(VirtIODevice *vdev, int idx, bool mask)
128{
129 VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
130
131 vhost_virtqueue_mask(&i2c->vhost_dev, vdev, idx, mask);
132}
133
134static bool vu_i2c_guest_notifier_pending(VirtIODevice *vdev, int idx)
135{
136 VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
137
138 return vhost_virtqueue_pending(&i2c->vhost_dev, idx);
139}
140
141static void do_vhost_user_cleanup(VirtIODevice *vdev, VHostUserI2C *i2c)
142{
143 vhost_user_cleanup(&i2c->vhost_user);
144 virtio_delete_queue(i2c->vq);
145 virtio_cleanup(vdev);
146 g_free(i2c->vhost_dev.vqs);
147 i2c->vhost_dev.vqs = NULL;
148}
149
150static int vu_i2c_connect(DeviceState *dev)
151{
152 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
153 VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
154
155 if (i2c->connected) {
156 return 0;
157 }
158 i2c->connected = true;
159
160
161 if (virtio_device_started(vdev, vdev->status)) {
162 vu_i2c_start(vdev);
163 }
164
165 return 0;
166}
167
168static void vu_i2c_disconnect(DeviceState *dev)
169{
170 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
171 VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
172
173 if (!i2c->connected) {
174 return;
175 }
176 i2c->connected = false;
177
178 if (vhost_dev_is_started(&i2c->vhost_dev)) {
179 vu_i2c_stop(vdev);
180 }
181}
182
183static void vu_i2c_event(void *opaque, QEMUChrEvent event)
184{
185 DeviceState *dev = opaque;
186 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
187 VHostUserI2C *i2c = VHOST_USER_I2C(vdev);
188
189 switch (event) {
190 case CHR_EVENT_OPENED:
191 if (vu_i2c_connect(dev) < 0) {
192 qemu_chr_fe_disconnect(&i2c->chardev);
193 return;
194 }
195 break;
196 case CHR_EVENT_CLOSED:
197 vu_i2c_disconnect(dev);
198 break;
199 case CHR_EVENT_BREAK:
200 case CHR_EVENT_MUX_IN:
201 case CHR_EVENT_MUX_OUT:
202
203 break;
204 }
205}
206
207static void vu_i2c_device_realize(DeviceState *dev, Error **errp)
208{
209 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
210 VHostUserI2C *i2c = VHOST_USER_I2C(dev);
211 int ret;
212
213 if (!i2c->chardev.chr) {
214 error_setg(errp, "vhost-user-i2c: missing chardev");
215 return;
216 }
217
218 if (!vhost_user_init(&i2c->vhost_user, &i2c->chardev, errp)) {
219 return;
220 }
221
222 virtio_init(vdev, VIRTIO_ID_I2C_ADAPTER, 0);
223
224 i2c->vhost_dev.nvqs = 1;
225 i2c->vq = virtio_add_queue(vdev, 4, vu_i2c_handle_output);
226 i2c->vhost_dev.vqs = g_new0(struct vhost_virtqueue, i2c->vhost_dev.nvqs);
227
228 ret = vhost_dev_init(&i2c->vhost_dev, &i2c->vhost_user,
229 VHOST_BACKEND_TYPE_USER, 0, errp);
230 if (ret < 0) {
231 do_vhost_user_cleanup(vdev, i2c);
232 }
233
234 qemu_chr_fe_set_handlers(&i2c->chardev, NULL, NULL, vu_i2c_event, NULL,
235 dev, NULL, true);
236}
237
238static void vu_i2c_device_unrealize(DeviceState *dev)
239{
240 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
241 VHostUserI2C *i2c = VHOST_USER_I2C(dev);
242
243
244 vu_i2c_set_status(vdev, 0);
245 vhost_dev_cleanup(&i2c->vhost_dev);
246 do_vhost_user_cleanup(vdev, i2c);
247}
248
249static const VMStateDescription vu_i2c_vmstate = {
250 .name = "vhost-user-i2c",
251 .unmigratable = 1,
252};
253
254static Property vu_i2c_properties[] = {
255 DEFINE_PROP_CHR("chardev", VHostUserI2C, chardev),
256 DEFINE_PROP_END_OF_LIST(),
257};
258
259static void vu_i2c_class_init(ObjectClass *klass, void *data)
260{
261 DeviceClass *dc = DEVICE_CLASS(klass);
262 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
263
264 device_class_set_props(dc, vu_i2c_properties);
265 dc->vmsd = &vu_i2c_vmstate;
266 set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
267 vdc->realize = vu_i2c_device_realize;
268 vdc->unrealize = vu_i2c_device_unrealize;
269 vdc->get_features = vu_i2c_get_features;
270 vdc->set_status = vu_i2c_set_status;
271 vdc->guest_notifier_mask = vu_i2c_guest_notifier_mask;
272 vdc->guest_notifier_pending = vu_i2c_guest_notifier_pending;
273}
274
275static const TypeInfo vu_i2c_info = {
276 .name = TYPE_VHOST_USER_I2C,
277 .parent = TYPE_VIRTIO_DEVICE,
278 .instance_size = sizeof(VHostUserI2C),
279 .class_init = vu_i2c_class_init,
280};
281
282static void vu_i2c_register_types(void)
283{
284 type_register_static(&vu_i2c_info);
285}
286
287type_init(vu_i2c_register_types)
288