LXR uboot/drivers/virtio/virtio_pci

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
   4 *
   5 * VirtIO PCI bus transport driver
   6 * Ported from Linux drivers/virtio/virtio_pci*.c
   7 */
   8
   9#include <common.h>
  10#include <dm.h>
  11#include <log.h>
  12#include <virtio_types.h>
  13#include <virtio.h>
  14#include <virtio_ring.h>
  15#include <dm/device.h>
  16#include <linux/bug.h>
  17#include <linux/compat.h>
  18#include <linux/err.h>
  19#include <linux/io.h>
  20#include "virtio_pci.h"
  21
  22#define VIRTIO_PCI_DRV_NAME     "virtio-pci.l"
  23
  24/* PCI device ID in the range 0x1000 to 0x103f */
  25#define VIRTIO_PCI_VENDOR_ID    0x1af4
  26#define VIRTIO_PCI_DEVICE_ID00  0x1000
  27#define VIRTIO_PCI_DEVICE_ID01  0x1001
  28#define VIRTIO_PCI_DEVICE_ID02  0x1002
  29#define VIRTIO_PCI_DEVICE_ID03  0x1003
  30#define VIRTIO_PCI_DEVICE_ID04  0x1004
  31#define VIRTIO_PCI_DEVICE_ID05  0x1005
  32#define VIRTIO_PCI_DEVICE_ID06  0x1006
  33#define VIRTIO_PCI_DEVICE_ID07  0x1007
  34#define VIRTIO_PCI_DEVICE_ID08  0x1008
  35#define VIRTIO_PCI_DEVICE_ID09  0x1009
  36#define VIRTIO_PCI_DEVICE_ID0A  0x100a
  37#define VIRTIO_PCI_DEVICE_ID0B  0x100b
  38#define VIRTIO_PCI_DEVICE_ID0C  0x100c
  39#define VIRTIO_PCI_DEVICE_ID0D  0x100d
  40#define VIRTIO_PCI_DEVICE_ID0E  0x100e
  41#define VIRTIO_PCI_DEVICE_ID0F  0x100f
  42#define VIRTIO_PCI_DEVICE_ID10  0x1010
  43#define VIRTIO_PCI_DEVICE_ID11  0x1011
  44#define VIRTIO_PCI_DEVICE_ID12  0x1012
  45#define VIRTIO_PCI_DEVICE_ID13  0x1013
  46#define VIRTIO_PCI_DEVICE_ID14  0x1014
  47#define VIRTIO_PCI_DEVICE_ID15  0x1015
  48#define VIRTIO_PCI_DEVICE_ID16  0x1016
  49#define VIRTIO_PCI_DEVICE_ID17  0x1017
  50#define VIRTIO_PCI_DEVICE_ID18  0x1018
  51#define VIRTIO_PCI_DEVICE_ID19  0x1019
  52#define VIRTIO_PCI_DEVICE_ID1A  0x101a
  53#define VIRTIO_PCI_DEVICE_ID1B  0x101b
  54#define VIRTIO_PCI_DEVICE_ID1C  0x101c
  55#define VIRTIO_PCI_DEVICE_ID1D  0x101d
  56#define VIRTIO_PCI_DEVICE_ID1E  0x101e
  57#define VIRTIO_PCI_DEVICE_ID1F  0x101f
  58#define VIRTIO_PCI_DEVICE_ID20  0x1020
  59#define VIRTIO_PCI_DEVICE_ID21  0x1021
  60#define VIRTIO_PCI_DEVICE_ID22  0x1022
  61#define VIRTIO_PCI_DEVICE_ID23  0x1023
  62#define VIRTIO_PCI_DEVICE_ID24  0x1024
  63#define VIRTIO_PCI_DEVICE_ID25  0x1025
  64#define VIRTIO_PCI_DEVICE_ID26  0x1026
  65#define VIRTIO_PCI_DEVICE_ID27  0x1027
  66#define VIRTIO_PCI_DEVICE_ID28  0x1028
  67#define VIRTIO_PCI_DEVICE_ID29  0x1029
  68#define VIRTIO_PCI_DEVICE_ID2A  0x102a
  69#define VIRTIO_PCI_DEVICE_ID2B  0x102b
  70#define VIRTIO_PCI_DEVICE_ID2C  0x102c
  71#define VIRTIO_PCI_DEVICE_ID2D  0x102d
  72#define VIRTIO_PCI_DEVICE_ID2E  0x102e
  73#define VIRTIO_PCI_DEVICE_ID2F  0x102f
  74#define VIRTIO_PCI_DEVICE_ID30  0x1030
  75#define VIRTIO_PCI_DEVICE_ID31  0x1031
  76#define VIRTIO_PCI_DEVICE_ID32  0x1032
  77#define VIRTIO_PCI_DEVICE_ID33  0x1033
  78#define VIRTIO_PCI_DEVICE_ID34  0x1034
  79#define VIRTIO_PCI_DEVICE_ID35  0x1035
  80#define VIRTIO_PCI_DEVICE_ID36  0x1036
  81#define VIRTIO_PCI_DEVICE_ID37  0x1037
  82#define VIRTIO_PCI_DEVICE_ID38  0x1038
  83#define VIRTIO_PCI_DEVICE_ID39  0x1039
  84#define VIRTIO_PCI_DEVICE_ID3A  0x103a
  85#define VIRTIO_PCI_DEVICE_ID3B  0x103b
  86#define VIRTIO_PCI_DEVICE_ID3C  0x103c
  87#define VIRTIO_PCI_DEVICE_ID3D  0x103d
  88#define VIRTIO_PCI_DEVICE_ID3E  0x103e
  89#define VIRTIO_PCI_DEVICE_ID3F  0x103f
  90
  91/**
  92 * virtio pci transport driver private data
  93 *
  94 * @ioaddr:     pci transport device register base
  95 * @version:    pci transport device version
  96 */
  97struct virtio_pci_priv {
  98        void __iomem *ioaddr;
  99};
 100
 101static int virtio_pci_get_config(struct udevice *udev, unsigned int offset,
 102                                 void *buf, unsigned int len)
 103{
 104        struct virtio_pci_priv *priv = dev_get_priv(udev);
 105        void __iomem *ioaddr = priv->ioaddr + VIRTIO_PCI_CONFIG_OFF(false);
 106        u8 *ptr = buf;
 107        int i;
 108
 109        for (i = 0; i < len; i++)
 110                ptr[i] = ioread8(ioaddr + i);
 111
 112        return 0;
 113}
 114
 115static int virtio_pci_set_config(struct udevice *udev, unsigned int offset,
 116                                 const void *buf, unsigned int len)
 117{
 118        struct virtio_pci_priv *priv = dev_get_priv(udev);
 119        void __iomem *ioaddr = priv->ioaddr + VIRTIO_PCI_CONFIG_OFF(false);
 120        const u8 *ptr = buf;
 121        int i;
 122
 123        for (i = 0; i < len; i++)
 124                iowrite8(ptr[i], ioaddr + i);
 125
 126        return 0;
 127}
 128
 129static int virtio_pci_get_status(struct udevice *udev, u8 *status)
 130{
 131        struct virtio_pci_priv *priv = dev_get_priv(udev);
 132
 133        *status = ioread8(priv->ioaddr + VIRTIO_PCI_STATUS);
 134
 135        return 0;
 136}
 137
 138static int virtio_pci_set_status(struct udevice *udev, u8 status)
 139{
 140        struct virtio_pci_priv *priv = dev_get_priv(udev);
 141
 142        /* We should never be setting status to 0 */
 143        WARN_ON(status == 0);
 144
 145        iowrite8(status, priv->ioaddr + VIRTIO_PCI_STATUS);
 146
 147        return 0;
 148}
 149
 150static int virtio_pci_reset(struct udevice *udev)
 151{
 152        struct virtio_pci_priv *priv = dev_get_priv(udev);
 153
 154        /* 0 status means a reset */
 155        iowrite8(0, priv->ioaddr + VIRTIO_PCI_STATUS);
 156
 157        /*
 158         * Flush out the status write, and flush in device writes,
 159         * including MSI-X interrupts, if any.
 160         */
 161        ioread8(priv->ioaddr + VIRTIO_PCI_STATUS);
 162
 163        return 0;
 164}
 165
 166static int virtio_pci_get_features(struct udevice *udev, u64 *features)
 167{
 168        struct virtio_pci_priv *priv = dev_get_priv(udev);
 169
 170        /*
 171         * When someone needs more than 32 feature bits, we'll need to
 172         * steal a bit to indicate that the rest are somewhere else.
 173         */
 174        *features = ioread32(priv->ioaddr + VIRTIO_PCI_HOST_FEATURES);
 175
 176        return 0;
 177}
 178
 179static int virtio_pci_set_features(struct udevice *udev)
 180{
 181        struct virtio_pci_priv *priv = dev_get_priv(udev);
 182        struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
 183
 184        /* Make sure we don't have any features > 32 bits! */
 185        WARN_ON((u32)uc_priv->features != uc_priv->features);
 186
 187        /* We only support 32 feature bits */
 188        iowrite32(uc_priv->features, priv->ioaddr + VIRTIO_PCI_GUEST_FEATURES);
 189
 190        return 0;
 191}
 192
 193static struct virtqueue *virtio_pci_setup_vq(struct udevice *udev,
 194                                             unsigned int index)
 195{
 196        struct virtio_pci_priv *priv = dev_get_priv(udev);
 197        struct virtqueue *vq;
 198        unsigned int num;
 199        int err;
 200
 201        /* Select the queue we're interested in */
 202        iowrite16(index, priv->ioaddr + VIRTIO_PCI_QUEUE_SEL);
 203
 204        /* Check if queue is either not available or already active */
 205        num = ioread16(priv->ioaddr + VIRTIO_PCI_QUEUE_NUM);
 206        if (!num || ioread32(priv->ioaddr + VIRTIO_PCI_QUEUE_PFN)) {
 207                err = -ENOENT;
 208                goto error_available;
 209        }
 210
 211        /* Create the vring */
 212        vq = vring_create_virtqueue(index, num, VIRTIO_PCI_VRING_ALIGN, udev);
 213        if (!vq) {
 214                err = -ENOMEM;
 215                goto error_available;
 216        }
 217
 218        /* Activate the queue */
 219        iowrite32(virtqueue_get_desc_addr(vq) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT,
 220                  priv->ioaddr + VIRTIO_PCI_QUEUE_PFN);
 221
 222        return vq;
 223
 224error_available:
 225        return ERR_PTR(err);
 226}
 227
 228static void virtio_pci_del_vq(struct virtqueue *vq)
 229{
 230        struct virtio_pci_priv *priv = dev_get_priv(vq->vdev);
 231        unsigned int index = vq->index;
 232
 233        iowrite16(index, priv->ioaddr + VIRTIO_PCI_QUEUE_SEL);
 234
 235        /* Select and deactivate the queue */
 236        iowrite32(0, priv->ioaddr + VIRTIO_PCI_QUEUE_PFN);
 237
 238        vring_del_virtqueue(vq);
 239}
 240
 241static int virtio_pci_del_vqs(struct udevice *udev)
 242{
 243        struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
 244        struct virtqueue *vq, *n;
 245
 246        list_for_each_entry_safe(vq, n, &uc_priv->vqs, list)
 247                virtio_pci_del_vq(vq);
 248
 249        return 0;
 250}
 251
 252static int virtio_pci_find_vqs(struct udevice *udev, unsigned int nvqs,
 253                               struct virtqueue *vqs[])
 254{
 255        int i;
 256
 257        for (i = 0; i < nvqs; ++i) {
 258                vqs[i] = virtio_pci_setup_vq(udev, i);
 259                if (IS_ERR(vqs[i])) {
 260                        virtio_pci_del_vqs(udev);
 261                        return PTR_ERR(vqs[i]);
 262                }
 263        }
 264
 265        return 0;
 266}
 267
 268static int virtio_pci_notify(struct udevice *udev, struct virtqueue *vq)
 269{
 270        struct virtio_pci_priv *priv = dev_get_priv(udev);
 271
 272        /*
 273         * We write the queue's selector into the notification register
 274         * to signal the other end
 275         */
 276        iowrite16(vq->index, priv->ioaddr + VIRTIO_PCI_QUEUE_NOTIFY);
 277
 278        return 0;
 279}
 280
 281static int virtio_pci_bind(struct udevice *udev)
 282{
 283        static unsigned int num_devs;
 284        char name[20];
 285
 286        /* Create a unique device name for PCI type devices */
 287        sprintf(name, "%s#%u", VIRTIO_PCI_DRV_NAME, num_devs++);
 288        device_set_name(udev, name);
 289
 290        return 0;
 291}
 292
 293static int virtio_pci_probe(struct udevice *udev)
 294{
 295        struct pci_child_plat *pplat = dev_get_parent_plat(udev);
 296        struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
 297        struct virtio_pci_priv *priv = dev_get_priv(udev);
 298        u16 subvendor, subdevice;
 299        u8 revision;
 300
 301        /* We only own devices >= 0x1000 and <= 0x103f: leave the rest. */
 302        if (pplat->device < 0x1000 || pplat->device > 0x103f)
 303                return -ENODEV;
 304
 305        /* Transitional devices must have a PCI revision ID of 0 */
 306        dm_pci_read_config8(udev, PCI_REVISION_ID, &revision);
 307        if (revision != VIRTIO_PCI_ABI_VERSION) {
 308                printf("(%s): virtio_pci expected ABI version %d, got %d\n",
 309                       udev->name, VIRTIO_PCI_ABI_VERSION, revision);
 310                return -ENODEV;
 311        }
 312
 313        /*
 314         * Transitional devices must have the PCI subsystem device ID matching
 315         * the virtio device ID
 316         */
 317        dm_pci_read_config16(udev, PCI_SUBSYSTEM_ID, &subdevice);
 318        dm_pci_read_config16(udev, PCI_SUBSYSTEM_VENDOR_ID, &subvendor);
 319        uc_priv->device = subdevice;
 320        uc_priv->vendor = subvendor;
 321
 322        priv->ioaddr = dm_pci_map_bar(udev, PCI_BASE_ADDRESS_0, PCI_REGION_IO);
 323        if (!priv->ioaddr)
 324                return -ENXIO;
 325        debug("(%s): virtio legacy device reg base %04lx\n",
 326              udev->name, (ulong)priv->ioaddr);
 327
 328        debug("(%s): device (%d) vendor (%08x) version (%d)\n", udev->name,
 329              uc_priv->device, uc_priv->vendor, revision);
 330
 331        return 0;
 332}
 333
 334static const struct dm_virtio_ops virtio_pci_ops = {
 335        .get_config     = virtio_pci_get_config,
 336        .set_config     = virtio_pci_set_config,
 337        .get_status     = virtio_pci_get_status,
 338        .set_status     = virtio_pci_set_status,
 339        .reset          = virtio_pci_reset,
 340        .get_features   = virtio_pci_get_features,
 341        .set_features   = virtio_pci_set_features,
 342        .find_vqs       = virtio_pci_find_vqs,
 343        .del_vqs        = virtio_pci_del_vqs,
 344        .notify         = virtio_pci_notify,
 345};
 346
 347U_BOOT_DRIVER(virtio_pci_legacy) = {
 348        .name   = VIRTIO_PCI_DRV_NAME,
 349        .id     = UCLASS_VIRTIO,
 350        .ops    = &virtio_pci_ops,
 351        .bind   = virtio_pci_bind,
 352        .probe  = virtio_pci_probe,
 353        .priv_auto      = sizeof(struct virtio_pci_priv),
 354};
 355
 356static struct pci_device_id virtio_pci_supported[] = {
 357        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID00) },
 358        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID01) },
 359        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID02) },
 360        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID03) },
 361        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID04) },
 362        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID05) },
 363        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID06) },
 364        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID07) },
 365        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID08) },
 366        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID09) },
 367        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0A) },
 368        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0B) },
 369        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0C) },
 370        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0D) },
 371        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0E) },
 372        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0F) },
 373        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID10) },
 374        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID11) },
 375        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID12) },
 376        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID13) },
 377        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID14) },
 378        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID15) },
 379        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID16) },
 380        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID17) },
 381        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID18) },
 382        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID19) },
 383        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1A) },
 384        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1B) },
 385        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1C) },
 386        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1D) },
 387        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1E) },
 388        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1F) },
 389        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID20) },
 390        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID21) },
 391        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID22) },
 392        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID23) },
 393        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID24) },
 394        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID25) },
 395        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID26) },
 396        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID27) },
 397        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID28) },
 398        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID29) },
 399        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2A) },
 400        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2B) },
 401        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2C) },
 402        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2D) },
 403        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2E) },
 404        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2F) },
 405        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID30) },
 406        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID31) },
 407        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID32) },
 408        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID33) },
 409        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID34) },
 410        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID35) },
 411        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID36) },
 412        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID37) },
 413        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID38) },
 414        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID39) },
 415        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3A) },
 416        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3B) },
 417        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3C) },
 418        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3D) },
 419        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3E) },
 420        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3F) },
 421        {},
 422};
 423
 424U_BOOT_PCI_DEVICE(virtio_pci_legacy, virtio_pci_supported);
 425