1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
4 * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
6 * VirtIO is a virtualization standard for network and disk device drivers
7 * where just the guest's device driver "knows" it is running in a virtual
8 * environment, and cooperates with the hypervisor. This enables guests to
9 * get high performance network and disk operations, and gives most of the
10 * performance benefits of paravirtualization. In the U-Boot case, the guest
11 * is U-Boot itself, while the virtual environment are normally QEMU targets
12 * like ARM, RISC-V and x86.
14 * See http://docs.oasis-open.org/virtio/virtio/v1.0/virtio-v1.0.pdf for
15 * the VirtIO specification v1.0.
18 #define LOG_CATEGORY UCLASS_VIRTIO
24 #include <virtio_types.h>
27 #include <linux/bug.h>
29 static const char *const virtio_drv_name[VIRTIO_ID_MAX_NUM] = {
30 [VIRTIO_ID_NET] = VIRTIO_NET_DRV_NAME,
31 [VIRTIO_ID_BLOCK] = VIRTIO_BLK_DRV_NAME,
32 [VIRTIO_ID_RNG] = VIRTIO_RNG_DRV_NAME,
35 int virtio_get_config(struct udevice *vdev, unsigned int offset,
36 void *buf, unsigned int len)
38 struct dm_virtio_ops *ops;
40 ops = virtio_get_ops(vdev->parent);
42 return ops->get_config(vdev->parent, offset, buf, len);
45 int virtio_set_config(struct udevice *vdev, unsigned int offset,
46 void *buf, unsigned int len)
48 struct dm_virtio_ops *ops;
50 ops = virtio_get_ops(vdev->parent);
52 return ops->set_config(vdev->parent, offset, buf, len);
55 int virtio_generation(struct udevice *vdev, u32 *counter)
57 struct dm_virtio_ops *ops;
59 ops = virtio_get_ops(vdev->parent);
63 return ops->generation(vdev->parent, counter);
66 int virtio_get_status(struct udevice *vdev, u8 *status)
68 struct dm_virtio_ops *ops;
70 ops = virtio_get_ops(vdev->parent);
72 return ops->get_status(vdev->parent, status);
75 int virtio_set_status(struct udevice *vdev, u8 status)
77 struct dm_virtio_ops *ops;
79 ops = virtio_get_ops(vdev->parent);
81 return ops->set_status(vdev->parent, status);
84 int virtio_reset(struct udevice *vdev)
86 struct dm_virtio_ops *ops;
88 ops = virtio_get_ops(vdev->parent);
90 return ops->reset(vdev->parent);
93 int virtio_get_features(struct udevice *vdev, u64 *features)
95 struct dm_virtio_ops *ops;
97 ops = virtio_get_ops(vdev->parent);
99 return ops->get_features(vdev->parent, features);
102 int virtio_set_features(struct udevice *vdev)
104 struct dm_virtio_ops *ops;
106 ops = virtio_get_ops(vdev->parent);
108 return ops->set_features(vdev->parent);
111 int virtio_find_vqs(struct udevice *vdev, unsigned int nvqs,
112 struct virtqueue *vqs[])
114 struct dm_virtio_ops *ops;
116 ops = virtio_get_ops(vdev->parent);
118 return ops->find_vqs(vdev->parent, nvqs, vqs);
121 int virtio_del_vqs(struct udevice *vdev)
123 struct dm_virtio_ops *ops;
125 ops = virtio_get_ops(vdev->parent);
127 return ops->del_vqs(vdev->parent);
130 int virtio_notify(struct udevice *vdev, struct virtqueue *vq)
132 struct dm_virtio_ops *ops;
134 ops = virtio_get_ops(vdev->parent);
136 return ops->notify(vdev->parent, vq);
139 void virtio_add_status(struct udevice *vdev, u8 status)
143 if (!virtio_get_status(vdev, &old))
144 virtio_set_status(vdev, old | status);
147 int virtio_finalize_features(struct udevice *vdev)
149 struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(vdev->parent);
153 ret = virtio_set_features(vdev);
160 virtio_add_status(vdev, VIRTIO_CONFIG_S_FEATURES_OK);
161 ret = virtio_get_status(vdev, &status);
164 if (!(status & VIRTIO_CONFIG_S_FEATURES_OK)) {
165 debug("(%s): device refuses features %x\n", vdev->name, status);
172 void virtio_driver_features_init(struct virtio_dev_priv *priv,
175 const u32 *feature_legacy,
176 u32 feature_legacy_size)
178 priv->feature_table = feature;
179 priv->feature_table_size = feature_size;
180 priv->feature_table_legacy = feature_legacy;
181 priv->feature_table_size_legacy = feature_legacy_size;
184 int virtio_init(void)
189 /* Enumerate all known virtio devices */
190 ret = uclass_first_device(UCLASS_VIRTIO, &bus);
195 ret = uclass_next_device(&bus);
203 static int virtio_uclass_pre_probe(struct udevice *udev)
205 struct dm_virtio_ops *ops;
207 ops = (struct dm_virtio_ops *)(udev->driver->ops);
210 * Check virtio transport driver ops here so that we don't need
211 * check these ops each time when the virtio_xxx APIs are called.
213 * Only generation op is optional. All other ops are must-have.
215 if (!ops->get_config || !ops->set_config ||
216 !ops->get_status || !ops->set_status ||
217 !ops->get_features || !ops->set_features ||
218 !ops->find_vqs || !ops->del_vqs ||
219 !ops->reset || !ops->notify)
225 static int virtio_uclass_post_probe(struct udevice *udev)
227 struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
228 char dev_name[30], *str;
229 struct udevice *vdev;
232 if (uc_priv->device >= VIRTIO_ID_MAX_NUM) {
233 debug("(%s): virtio device ID %d exceeds maximum num\n",
234 udev->name, uc_priv->device);
238 if (!virtio_drv_name[uc_priv->device]) {
239 debug("(%s): underlying virtio device driver unavailable\n",
244 snprintf(dev_name, sizeof(dev_name), "%s#%d",
245 virtio_drv_name[uc_priv->device], dev_seq(udev));
246 str = strdup(dev_name);
250 ret = device_bind_driver(udev, virtio_drv_name[uc_priv->device],
252 if (ret == -ENOENT) {
253 debug("(%s): no driver configured\n", udev->name);
260 device_set_name_alloced(vdev);
262 INIT_LIST_HEAD(&uc_priv->vqs);
267 static int virtio_uclass_child_post_bind(struct udevice *vdev)
269 /* Acknowledge that we've seen the device */
270 virtio_add_status(vdev, VIRTIO_CONFIG_S_ACKNOWLEDGE);
275 static int virtio_uclass_child_pre_probe(struct udevice *vdev)
277 struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(vdev->parent);
280 u64 driver_features_legacy;
285 * Save the real virtio device (eg: virtio-net, virtio-blk) to
286 * the transport (parent) device's uclass priv for future use.
288 uc_priv->vdev = vdev;
291 * We always start by resetting the device, in case a previous driver
292 * messed it up. This also tests that code path a little.
294 ret = virtio_reset(vdev);
298 /* We have a driver! */
299 virtio_add_status(vdev, VIRTIO_CONFIG_S_DRIVER);
301 /* Figure out what features the device supports */
302 virtio_get_features(vdev, &device_features);
303 debug("(%s) plain device features supported %016llx\n",
304 vdev->name, device_features);
305 if (!(device_features & (1ULL << VIRTIO_F_VERSION_1)))
306 uc_priv->legacy = true;
308 /* Figure out what features the driver supports */
310 for (i = 0; i < uc_priv->feature_table_size; i++) {
311 unsigned int f = uc_priv->feature_table[i];
314 driver_features |= (1ULL << f);
317 /* Some drivers have a separate feature table for virtio v1.0 */
318 if (uc_priv->feature_table_legacy) {
319 driver_features_legacy = 0;
320 for (i = 0; i < uc_priv->feature_table_size_legacy; i++) {
321 unsigned int f = uc_priv->feature_table_legacy[i];
324 driver_features_legacy |= (1ULL << f);
327 driver_features_legacy = driver_features;
330 if (uc_priv->legacy) {
331 debug("(%s): legacy virtio device\n", vdev->name);
332 uc_priv->features = driver_features_legacy & device_features;
334 debug("(%s): v1.0 complaint virtio device\n", vdev->name);
335 uc_priv->features = driver_features & device_features;
338 /* Transport features always preserved to pass to finalize_features */
339 for (i = VIRTIO_TRANSPORT_F_START; i < VIRTIO_TRANSPORT_F_END; i++)
340 if ((device_features & (1ULL << i)) &&
341 (i == VIRTIO_F_VERSION_1))
342 __virtio_set_bit(vdev->parent, i);
344 debug("(%s) final negotiated features supported %016llx\n",
345 vdev->name, uc_priv->features);
346 ret = virtio_finalize_features(vdev);
353 virtio_add_status(vdev, VIRTIO_CONFIG_S_FAILED);
357 static int virtio_uclass_child_post_probe(struct udevice *vdev)
359 /* Indicates that the driver is set up and ready to drive the device */
360 virtio_add_status(vdev, VIRTIO_CONFIG_S_DRIVER_OK);
365 UCLASS_DRIVER(virtio) = {
368 .flags = DM_UC_FLAG_SEQ_ALIAS,
369 .pre_probe = virtio_uclass_pre_probe,
370 .post_probe = virtio_uclass_post_probe,
371 .child_post_bind = virtio_uclass_child_post_bind,
372 .child_pre_probe = virtio_uclass_child_pre_probe,
373 .child_post_probe = virtio_uclass_child_post_probe,
374 .per_device_auto = sizeof(struct virtio_dev_priv),