4 * Copyright (C) 2012 : GreenSocs Ltd
5 * http://www.greensocs.com/ , email: info@greensocs.com
8 * Frederic Konrad <fred.konrad@greensocs.com>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation, either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, see <http://www.gnu.org/licenses/>.
25 #include "qemu/osdep.h"
27 #include "qemu/error-report.h"
29 #include "hw/virtio/virtio-bus.h"
30 #include "hw/virtio/virtio.h"
32 /* #define DEBUG_VIRTIO_BUS */
34 #ifdef DEBUG_VIRTIO_BUS
35 #define DPRINTF(fmt, ...) \
36 do { printf("virtio_bus: " fmt , ## __VA_ARGS__); } while (0)
38 #define DPRINTF(fmt, ...) do { } while (0)
41 /* A VirtIODevice is being plugged */
42 void virtio_bus_device_plugged(VirtIODevice
*vdev
, Error
**errp
)
44 DeviceState
*qdev
= DEVICE(vdev
);
45 BusState
*qbus
= BUS(qdev_get_parent_bus(qdev
));
46 VirtioBusState
*bus
= VIRTIO_BUS(qbus
);
47 VirtioBusClass
*klass
= VIRTIO_BUS_GET_CLASS(bus
);
48 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_GET_CLASS(vdev
);
50 DPRINTF("%s: plug device.\n", qbus
->name
);
52 if (klass
->pre_plugged
!= NULL
) {
53 klass
->pre_plugged(qbus
->parent
, errp
);
56 /* Get the features of the plugged device. */
57 assert(vdc
->get_features
!= NULL
);
58 vdev
->host_features
= vdc
->get_features(vdev
, vdev
->host_features
,
61 if (klass
->device_plugged
!= NULL
) {
62 klass
->device_plugged(qbus
->parent
, errp
);
66 /* Reset the virtio_bus */
67 void virtio_bus_reset(VirtioBusState
*bus
)
69 VirtIODevice
*vdev
= virtio_bus_get_device(bus
);
71 DPRINTF("%s: reset device.\n", BUS(bus
)->name
);
77 /* A VirtIODevice is being unplugged */
78 void virtio_bus_device_unplugged(VirtIODevice
*vdev
)
80 DeviceState
*qdev
= DEVICE(vdev
);
81 BusState
*qbus
= BUS(qdev_get_parent_bus(qdev
));
82 VirtioBusClass
*klass
= VIRTIO_BUS_GET_CLASS(qbus
);
84 DPRINTF("%s: remove device.\n", qbus
->name
);
87 if (klass
->device_unplugged
!= NULL
) {
88 klass
->device_unplugged(qbus
->parent
);
93 /* Get the device id of the plugged device. */
94 uint16_t virtio_bus_get_vdev_id(VirtioBusState
*bus
)
96 VirtIODevice
*vdev
= virtio_bus_get_device(bus
);
98 return vdev
->device_id
;
101 /* Get the config_len field of the plugged device. */
102 size_t virtio_bus_get_vdev_config_len(VirtioBusState
*bus
)
104 VirtIODevice
*vdev
= virtio_bus_get_device(bus
);
105 assert(vdev
!= NULL
);
106 return vdev
->config_len
;
109 /* Get bad features of the plugged device. */
110 uint32_t virtio_bus_get_vdev_bad_features(VirtioBusState
*bus
)
112 VirtIODevice
*vdev
= virtio_bus_get_device(bus
);
113 VirtioDeviceClass
*k
;
115 assert(vdev
!= NULL
);
116 k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
117 if (k
->bad_features
!= NULL
) {
118 return k
->bad_features(vdev
);
124 /* Get config of the plugged device. */
125 void virtio_bus_get_vdev_config(VirtioBusState
*bus
, uint8_t *config
)
127 VirtIODevice
*vdev
= virtio_bus_get_device(bus
);
128 VirtioDeviceClass
*k
;
130 assert(vdev
!= NULL
);
131 k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
132 if (k
->get_config
!= NULL
) {
133 k
->get_config(vdev
, config
);
137 /* Set config of the plugged device. */
138 void virtio_bus_set_vdev_config(VirtioBusState
*bus
, uint8_t *config
)
140 VirtIODevice
*vdev
= virtio_bus_get_device(bus
);
141 VirtioDeviceClass
*k
;
143 assert(vdev
!= NULL
);
144 k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
145 if (k
->set_config
!= NULL
) {
146 k
->set_config(vdev
, config
);
151 * This function handles both assigning the ioeventfd handler and
152 * registering it with the kernel.
153 * assign: register/deregister ioeventfd with the kernel
154 * set_handler: use the generic ioeventfd handler
156 static int set_host_notifier_internal(DeviceState
*proxy
, VirtioBusState
*bus
,
157 int n
, bool assign
, bool set_handler
)
159 VirtIODevice
*vdev
= virtio_bus_get_device(bus
);
160 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(bus
);
161 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
162 EventNotifier
*notifier
= virtio_queue_get_host_notifier(vq
);
166 r
= event_notifier_init(notifier
, 1);
168 error_report("%s: unable to init event notifier: %s (%d)",
169 __func__
, strerror(-r
), r
);
172 virtio_queue_set_host_notifier_fd_handler(vq
, true, set_handler
);
173 r
= k
->ioeventfd_assign(proxy
, notifier
, n
, assign
);
175 error_report("%s: unable to assign ioeventfd: %d", __func__
, r
);
176 virtio_queue_set_host_notifier_fd_handler(vq
, false, false);
177 event_notifier_cleanup(notifier
);
181 k
->ioeventfd_assign(proxy
, notifier
, n
, assign
);
182 virtio_queue_set_host_notifier_fd_handler(vq
, false, false);
183 event_notifier_cleanup(notifier
);
188 void virtio_bus_start_ioeventfd(VirtioBusState
*bus
)
190 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(bus
);
191 DeviceState
*proxy
= DEVICE(BUS(bus
)->parent
);
195 if (!k
->ioeventfd_started
|| k
->ioeventfd_started(proxy
)) {
198 if (k
->ioeventfd_disabled(proxy
)) {
201 vdev
= virtio_bus_get_device(bus
);
202 for (n
= 0; n
< VIRTIO_QUEUE_MAX
; n
++) {
203 if (!virtio_queue_get_num(vdev
, n
)) {
206 r
= set_host_notifier_internal(proxy
, bus
, n
, true, true);
211 k
->ioeventfd_set_started(proxy
, true, false);
216 if (!virtio_queue_get_num(vdev
, n
)) {
220 r
= set_host_notifier_internal(proxy
, bus
, n
, false, false);
223 k
->ioeventfd_set_started(proxy
, false, true);
224 error_report("%s: failed. Fallback to userspace (slower).", __func__
);
227 void virtio_bus_stop_ioeventfd(VirtioBusState
*bus
)
229 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(bus
);
230 DeviceState
*proxy
= DEVICE(BUS(bus
)->parent
);
234 if (!k
->ioeventfd_started
|| !k
->ioeventfd_started(proxy
)) {
237 vdev
= virtio_bus_get_device(bus
);
238 for (n
= 0; n
< VIRTIO_QUEUE_MAX
; n
++) {
239 if (!virtio_queue_get_num(vdev
, n
)) {
242 r
= set_host_notifier_internal(proxy
, bus
, n
, false, false);
245 k
->ioeventfd_set_started(proxy
, false, false);
249 * This function switches from/to the generic ioeventfd handler.
250 * assign==false means 'use generic ioeventfd handler'.
252 int virtio_bus_set_host_notifier(VirtioBusState
*bus
, int n
, bool assign
)
254 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(bus
);
255 DeviceState
*proxy
= DEVICE(BUS(bus
)->parent
);
257 if (!k
->ioeventfd_started
) {
260 k
->ioeventfd_set_disabled(proxy
, assign
);
263 * Stop using the generic ioeventfd, we are doing eventfd handling
266 * FIXME: We should just switch the handler and not deassign the
268 * Otherwise, there's a window where we don't have an
269 * ioeventfd and we may end up with a notification where
270 * we don't expect one.
272 virtio_bus_stop_ioeventfd(bus
);
274 return set_host_notifier_internal(proxy
, bus
, n
, assign
, false);
277 static char *virtio_bus_get_dev_path(DeviceState
*dev
)
279 BusState
*bus
= qdev_get_parent_bus(dev
);
280 DeviceState
*proxy
= DEVICE(bus
->parent
);
281 return qdev_get_dev_path(proxy
);
284 static char *virtio_bus_get_fw_dev_path(DeviceState
*dev
)
289 static void virtio_bus_class_init(ObjectClass
*klass
, void *data
)
291 BusClass
*bus_class
= BUS_CLASS(klass
);
292 bus_class
->get_dev_path
= virtio_bus_get_dev_path
;
293 bus_class
->get_fw_dev_path
= virtio_bus_get_fw_dev_path
;
296 static const TypeInfo virtio_bus_info
= {
297 .name
= TYPE_VIRTIO_BUS
,
299 .instance_size
= sizeof(VirtioBusState
),
301 .class_size
= sizeof(VirtioBusClass
),
302 .class_init
= virtio_bus_class_init
305 static void virtio_register_types(void)
307 type_register_static(&virtio_bus_info
);
310 type_init(virtio_register_types
)