uboot/drivers/virtio/virtio_pci_modern.c
<<
>>
Prefs 
   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/delay.h>
  19#include <linux/err.h>
  20#include <linux/io.h>
  21#include "virtio_pci.h"
  22
  23#define VIRTIO_PCI_DRV_NAME     "virtio-pci.m"
  24
  25/* PCI device ID in the range 0x1040 to 0x107f */
  26#define VIRTIO_PCI_VENDOR_ID    0x1af4
  27#define VIRTIO_PCI_DEVICE_ID00  0x1040
  28#define VIRTIO_PCI_DEVICE_ID01  0x1041
  29#define VIRTIO_PCI_DEVICE_ID02  0x1042
  30#define VIRTIO_PCI_DEVICE_ID03  0x1043
  31#define VIRTIO_PCI_DEVICE_ID04  0x1044
  32#define VIRTIO_PCI_DEVICE_ID05  0x1045
  33#define VIRTIO_PCI_DEVICE_ID06  0x1046
  34#define VIRTIO_PCI_DEVICE_ID07  0x1047
  35#define VIRTIO_PCI_DEVICE_ID08  0x1048
  36#define VIRTIO_PCI_DEVICE_ID09  0x1049
  37#define VIRTIO_PCI_DEVICE_ID0A  0x104a
  38#define VIRTIO_PCI_DEVICE_ID0B  0x104b
  39#define VIRTIO_PCI_DEVICE_ID0C  0x104c
  40#define VIRTIO_PCI_DEVICE_ID0D  0x104d
  41#define VIRTIO_PCI_DEVICE_ID0E  0x104e
  42#define VIRTIO_PCI_DEVICE_ID0F  0x104f
  43#define VIRTIO_PCI_DEVICE_ID10  0x1050
  44#define VIRTIO_PCI_DEVICE_ID11  0x1051
  45#define VIRTIO_PCI_DEVICE_ID12  0x1052
  46#define VIRTIO_PCI_DEVICE_ID13  0x1053
  47#define VIRTIO_PCI_DEVICE_ID14  0x1054
  48#define VIRTIO_PCI_DEVICE_ID15  0x1055
  49#define VIRTIO_PCI_DEVICE_ID16  0x1056
  50#define VIRTIO_PCI_DEVICE_ID17  0x1057
  51#define VIRTIO_PCI_DEVICE_ID18  0x1058
  52#define VIRTIO_PCI_DEVICE_ID19  0x1059
  53#define VIRTIO_PCI_DEVICE_ID1A  0x105a
  54#define VIRTIO_PCI_DEVICE_ID1B  0x105b
  55#define VIRTIO_PCI_DEVICE_ID1C  0x105c
  56#define VIRTIO_PCI_DEVICE_ID1D  0x105d
  57#define VIRTIO_PCI_DEVICE_ID1E  0x105e
  58#define VIRTIO_PCI_DEVICE_ID1F  0x105f
  59#define VIRTIO_PCI_DEVICE_ID20  0x1060
  60#define VIRTIO_PCI_DEVICE_ID21  0x1061
  61#define VIRTIO_PCI_DEVICE_ID22  0x1062
  62#define VIRTIO_PCI_DEVICE_ID23  0x1063
  63#define VIRTIO_PCI_DEVICE_ID24  0x1064
  64#define VIRTIO_PCI_DEVICE_ID25  0x1065
  65#define VIRTIO_PCI_DEVICE_ID26  0x1066
  66#define VIRTIO_PCI_DEVICE_ID27  0x1067
  67#define VIRTIO_PCI_DEVICE_ID28  0x1068
  68#define VIRTIO_PCI_DEVICE_ID29  0x1069
  69#define VIRTIO_PCI_DEVICE_ID2A  0x106a
  70#define VIRTIO_PCI_DEVICE_ID2B  0x106b
  71#define VIRTIO_PCI_DEVICE_ID2C  0x106c
  72#define VIRTIO_PCI_DEVICE_ID2D  0x106d
  73#define VIRTIO_PCI_DEVICE_ID2E  0x106e
  74#define VIRTIO_PCI_DEVICE_ID2F  0x106f
  75#define VIRTIO_PCI_DEVICE_ID30  0x1070
  76#define VIRTIO_PCI_DEVICE_ID31  0x1071
  77#define VIRTIO_PCI_DEVICE_ID32  0x1072
  78#define VIRTIO_PCI_DEVICE_ID33  0x1073
  79#define VIRTIO_PCI_DEVICE_ID34  0x1074
  80#define VIRTIO_PCI_DEVICE_ID35  0x1075
  81#define VIRTIO_PCI_DEVICE_ID36  0x1076
  82#define VIRTIO_PCI_DEVICE_ID37  0x1077
  83#define VIRTIO_PCI_DEVICE_ID38  0x1078
  84#define VIRTIO_PCI_DEVICE_ID39  0x1079
  85#define VIRTIO_PCI_DEVICE_ID3A  0x107a
  86#define VIRTIO_PCI_DEVICE_ID3B  0x107b
  87#define VIRTIO_PCI_DEVICE_ID3C  0x107c
  88#define VIRTIO_PCI_DEVICE_ID3D  0x107d
  89#define VIRTIO_PCI_DEVICE_ID3E  0x107e
  90#define VIRTIO_PCI_DEVICE_ID3F  0x107f
  91
  92/**
  93 * virtio pci transport driver private data
  94 *
  95 * @common: pci transport device common register block base
  96 * @notify_base: pci transport device notify register block base
  97 * @device: pci transport device device-specific register block base
  98 * @device_len: pci transport device device-specific register block length
  99 * @notify_offset_multiplier: multiply queue_notify_off by this value
 100 */
 101struct virtio_pci_priv {
 102        struct virtio_pci_common_cfg __iomem *common;
 103        void __iomem *notify_base;
 104        void __iomem *device;
 105        u32 device_len;
 106        u32 notify_offset_multiplier;
 107};
 108
 109static int virtio_pci_get_config(struct udevice *udev, unsigned int offset,
 110                                 void *buf, unsigned int len)
 111{
 112        struct virtio_pci_priv *priv = dev_get_priv(udev);
 113        u8 b;
 114        __le16 w;
 115        __le32 l;
 116
 117        WARN_ON(offset + len > priv->device_len);
 118
 119        switch (len) {
 120        case 1:
 121                b = ioread8(priv->device + offset);
 122                memcpy(buf, &b, sizeof(b));
 123                break;
 124        case 2:
 125                w = cpu_to_le16(ioread16(priv->device + offset));
 126                memcpy(buf, &w, sizeof(w));
 127                break;
 128        case 4:
 129                l = cpu_to_le32(ioread32(priv->device + offset));
 130                memcpy(buf, &l, sizeof(l));
 131                break;
 132        case 8:
 133                l = cpu_to_le32(ioread32(priv->device + offset));
 134                memcpy(buf, &l, sizeof(l));
 135                l = cpu_to_le32(ioread32(priv->device + offset + sizeof(l)));
 136                memcpy(buf + sizeof(l), &l, sizeof(l));
 137                break;
 138        default:
 139                WARN_ON(true);
 140        }
 141
 142        return 0;
 143}
 144
 145static int virtio_pci_set_config(struct udevice *udev, unsigned int offset,
 146                                 const void *buf, unsigned int len)
 147{
 148        struct virtio_pci_priv *priv = dev_get_priv(udev);
 149        u8 b;
 150        __le16 w;
 151        __le32 l;
 152
 153        WARN_ON(offset + len > priv->device_len);
 154
 155        switch (len) {
 156        case 1:
 157                memcpy(&b, buf, sizeof(b));
 158                iowrite8(b, priv->device + offset);
 159                break;
 160        case 2:
 161                memcpy(&w, buf, sizeof(w));
 162                iowrite16(le16_to_cpu(w), priv->device + offset);
 163                break;
 164        case 4:
 165                memcpy(&l, buf, sizeof(l));
 166                iowrite32(le32_to_cpu(l), priv->device + offset);
 167                break;
 168        case 8:
 169                memcpy(&l, buf, sizeof(l));
 170                iowrite32(le32_to_cpu(l), priv->device + offset);
 171                memcpy(&l, buf + sizeof(l), sizeof(l));
 172                iowrite32(le32_to_cpu(l), priv->device + offset + sizeof(l));
 173                break;
 174        default:
 175                WARN_ON(true);
 176        }
 177
 178        return 0;
 179}
 180
 181static int virtio_pci_generation(struct udevice *udev, u32 *counter)
 182{
 183        struct virtio_pci_priv *priv = dev_get_priv(udev);
 184
 185        *counter = ioread8(&priv->common->config_generation);
 186
 187        return 0;
 188}
 189
 190static int virtio_pci_get_status(struct udevice *udev, u8 *status)
 191{
 192        struct virtio_pci_priv *priv = dev_get_priv(udev);
 193
 194        *status = ioread8(&priv->common->device_status);
 195
 196        return 0;
 197}
 198
 199static int virtio_pci_set_status(struct udevice *udev, u8 status)
 200{
 201        struct virtio_pci_priv *priv = dev_get_priv(udev);
 202
 203        /* We should never be setting status to 0 */
 204        WARN_ON(status == 0);
 205
 206        iowrite8(status, &priv->common->device_status);
 207
 208        return 0;
 209}
 210
 211static int virtio_pci_reset(struct udevice *udev)
 212{
 213        struct virtio_pci_priv *priv = dev_get_priv(udev);
 214
 215        /* 0 status means a reset */
 216        iowrite8(0, &priv->common->device_status);
 217
 218        /*
 219         * After writing 0 to device_status, the driver MUST wait for a read
 220         * of device_status to return 0 before reinitializing the device.
 221         * This will flush out the status write, and flush in device writes,
 222         * including MSI-X interrupts, if any.
 223         */
 224        while (ioread8(&priv->common->device_status))
 225                udelay(1000);
 226
 227        return 0;
 228}
 229
 230static int virtio_pci_get_features(struct udevice *udev, u64 *features)
 231{
 232        struct virtio_pci_priv *priv = dev_get_priv(udev);
 233
 234        iowrite32(0, &priv->common->device_feature_select);
 235        *features = ioread32(&priv->common->device_feature);
 236        iowrite32(1, &priv->common->device_feature_select);
 237        *features |= ((u64)ioread32(&priv->common->device_feature) << 32);
 238
 239        return 0;
 240}
 241
 242static int virtio_pci_set_features(struct udevice *udev)
 243{
 244        struct virtio_pci_priv *priv = dev_get_priv(udev);
 245        struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
 246
 247        if (!__virtio_test_bit(udev, VIRTIO_F_VERSION_1)) {
 248                debug("virtio: device uses modern interface but does not have VIRTIO_F_VERSION_1\n");
 249                return -EINVAL;
 250        }
 251
 252        iowrite32(0, &priv->common->guest_feature_select);
 253        iowrite32((u32)uc_priv->features, &priv->common->guest_feature);
 254        iowrite32(1, &priv->common->guest_feature_select);
 255        iowrite32(uc_priv->features >> 32, &priv->common->guest_feature);
 256
 257        return 0;
 258}
 259
 260static struct virtqueue *virtio_pci_setup_vq(struct udevice *udev,
 261                                             unsigned int index)
 262{
 263        struct virtio_pci_priv *priv = dev_get_priv(udev);
 264        struct virtio_pci_common_cfg __iomem *cfg = priv->common;
 265        struct virtqueue *vq;
 266        u16 num;
 267        u64 addr;
 268        int err;
 269
 270        if (index >= ioread16(&cfg->num_queues))
 271                return ERR_PTR(-ENOENT);
 272
 273        /* Select the queue we're interested in */
 274        iowrite16(index, &cfg->queue_select);
 275
 276        /* Check if queue is either not available or already active */
 277        num = ioread16(&cfg->queue_size);
 278        if (!num || ioread16(&cfg->queue_enable))
 279                return ERR_PTR(-ENOENT);
 280
 281        if (num & (num - 1)) {
 282                printf("(%s): bad queue size %u", udev->name, num);
 283                return ERR_PTR(-EINVAL);
 284        }
 285
 286        /* Create the vring */
 287        vq = vring_create_virtqueue(index, num, VIRTIO_PCI_VRING_ALIGN, udev);
 288        if (!vq) {
 289                err = -ENOMEM;
 290                goto error_available;
 291        }
 292
 293        /* Activate the queue */
 294        iowrite16(virtqueue_get_vring_size(vq), &cfg->queue_size);
 295
 296        addr = virtqueue_get_desc_addr(vq);
 297        iowrite32((u32)addr, &cfg->queue_desc_lo);
 298        iowrite32(addr >> 32, &cfg->queue_desc_hi);
 299
 300        addr = virtqueue_get_avail_addr(vq);
 301        iowrite32((u32)addr, &cfg->queue_avail_lo);
 302        iowrite32(addr >> 32, &cfg->queue_avail_hi);
 303
 304        addr = virtqueue_get_used_addr(vq);
 305        iowrite32((u32)addr, &cfg->queue_used_lo);
 306        iowrite32(addr >> 32, &cfg->queue_used_hi);
 307
 308        iowrite16(1, &cfg->queue_enable);
 309
 310        return vq;
 311
 312error_available:
 313        return ERR_PTR(err);
 314}
 315
 316static void virtio_pci_del_vq(struct virtqueue *vq)
 317{
 318        struct virtio_pci_priv *priv = dev_get_priv(vq->vdev);
 319        unsigned int index = vq->index;
 320
 321        iowrite16(index, &priv->common->queue_select);
 322
 323        /* Select and deactivate the queue */
 324        iowrite16(0, &priv->common->queue_enable);
 325
 326        vring_del_virtqueue(vq);
 327}
 328
 329static int virtio_pci_del_vqs(struct udevice *udev)
 330{
 331        struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
 332        struct virtqueue *vq, *n;
 333
 334        list_for_each_entry_safe(vq, n, &uc_priv->vqs, list)
 335                virtio_pci_del_vq(vq);
 336
 337        return 0;
 338}
 339
 340static int virtio_pci_find_vqs(struct udevice *udev, unsigned int nvqs,
 341                               struct virtqueue *vqs[])
 342{
 343        int i;
 344
 345        for (i = 0; i < nvqs; ++i) {
 346                vqs[i] = virtio_pci_setup_vq(udev, i);
 347                if (IS_ERR(vqs[i])) {
 348                        virtio_pci_del_vqs(udev);
 349                        return PTR_ERR(vqs[i]);
 350                }
 351        }
 352
 353        return 0;
 354}
 355
 356static int virtio_pci_notify(struct udevice *udev, struct virtqueue *vq)
 357{
 358        struct virtio_pci_priv *priv = dev_get_priv(udev);
 359        u16 off;
 360
 361        /* Select the queue we're interested in */
 362        iowrite16(vq->index, &priv->common->queue_select);
 363
 364        /* get offset of notification word for this vq */
 365        off = ioread16(&priv->common->queue_notify_off);
 366
 367        /*
 368         * We write the queue's selector into the notification register
 369         * to signal the other end
 370         */
 371        iowrite16(vq->index,
 372                  priv->notify_base + off * priv->notify_offset_multiplier);
 373
 374        return 0;
 375}
 376
 377/**
 378 * virtio_pci_find_capability - walk capabilities to find device info
 379 *
 380 * @udev:       the transport device
 381 * @cfg_type:   the VIRTIO_PCI_CAP_* value we seek
 382 *
 383 * @return offset of the configuration structure
 384 */
 385static int virtio_pci_find_capability(struct udevice *udev, u8 cfg_type)
 386{
 387        int pos;
 388        int offset;
 389        u8 type, bar;
 390
 391        for (pos = dm_pci_find_capability(udev, PCI_CAP_ID_VNDR);
 392             pos > 0;
 393             pos = dm_pci_find_next_capability(udev, pos, PCI_CAP_ID_VNDR)) {
 394                offset = pos + offsetof(struct virtio_pci_cap, cfg_type);
 395                dm_pci_read_config8(udev, offset, &type);
 396                offset = pos + offsetof(struct virtio_pci_cap, bar);
 397                dm_pci_read_config8(udev, offset, &bar);
 398
 399                /* Ignore structures with reserved BAR values */
 400                if (bar > 0x5)
 401                        continue;
 402
 403                if (type == cfg_type)
 404                        return pos;
 405        }
 406
 407        return 0;
 408}
 409
 410/**
 411 * virtio_pci_map_capability - map base address of the capability
 412 *
 413 * @udev:       the transport device
 414 * @off:        offset of the configuration structure
 415 *
 416 * @return base address of the capability
 417 */
 418static void __iomem *virtio_pci_map_capability(struct udevice *udev, int off)
 419{
 420        u8 bar;
 421        u32 offset;
 422        ulong base;
 423        void __iomem *p;
 424
 425        if (!off)
 426                return NULL;
 427
 428        offset = off + offsetof(struct virtio_pci_cap, bar);
 429        dm_pci_read_config8(udev, offset, &bar);
 430        offset = off + offsetof(struct virtio_pci_cap, offset);
 431        dm_pci_read_config32(udev, offset, &offset);
 432
 433        /*
 434         * TODO: adding 64-bit BAR support
 435         *
 436         * Per spec, the BAR is permitted to be either 32-bit or 64-bit.
 437         * For simplicity, only read the BAR address as 32-bit.
 438         */
 439        base = dm_pci_read_bar32(udev, bar);
 440        p = (void __iomem *)base + offset;
 441
 442        return p;
 443}
 444
 445static int virtio_pci_bind(struct udevice *udev)
 446{
 447        static int num_devs;
 448        char name[20];
 449
 450        /* Create a unique device name  */
 451        sprintf(name, "%s#%u", VIRTIO_PCI_DRV_NAME, num_devs++);
 452        device_set_name(udev, name);
 453
 454        return 0;
 455}
 456
 457static int virtio_pci_probe(struct udevice *udev)
 458{
 459        struct pci_child_plat *pplat = dev_get_parent_plat(udev);
 460        struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
 461        struct virtio_pci_priv *priv = dev_get_priv(udev);
 462        u16 subvendor;
 463        u8 revision;
 464        int common, notify, device;
 465        int offset;
 466
 467        /* We only own devices >= 0x1040 and <= 0x107f: leave the rest. */
 468        if (pplat->device < 0x1040 || pplat->device > 0x107f)
 469                return -ENODEV;
 470
 471        /* Transitional devices must not have a PCI revision ID of 0 */
 472        dm_pci_read_config8(udev, PCI_REVISION_ID, &revision);
 473
 474        /* Modern devices: simply use PCI device id, but start from 0x1040. */
 475        uc_priv->device = pplat->device - 0x1040;
 476        dm_pci_read_config16(udev, PCI_SUBSYSTEM_VENDOR_ID, &subvendor);
 477        uc_priv->vendor = subvendor;
 478
 479        /* Check for a common config: if not, use legacy mode (bar 0) */
 480        common = virtio_pci_find_capability(udev, VIRTIO_PCI_CAP_COMMON_CFG);
 481        if (!common) {
 482                printf("(%s): leaving for legacy driver\n", udev->name);
 483                return -ENODEV;
 484        }
 485
 486        /* If common is there, notify should be too */
 487        notify = virtio_pci_find_capability(udev, VIRTIO_PCI_CAP_NOTIFY_CFG);
 488        if (!notify) {
 489                printf("(%s): missing capabilities %i/%i\n", udev->name,
 490                       common, notify);
 491                return -EINVAL;
 492        }
 493
 494        /*
 495         * Device capability is only mandatory for devices that have
 496         * device-specific configuration.
 497         */
 498        device = virtio_pci_find_capability(udev, VIRTIO_PCI_CAP_DEVICE_CFG);
 499        if (device) {
 500                offset = notify + offsetof(struct virtio_pci_cap, length);
 501                dm_pci_read_config32(udev, offset, &priv->device_len);
 502        }
 503
 504        /* Map configuration structures */
 505        priv->common = virtio_pci_map_capability(udev, common);
 506        priv->notify_base = virtio_pci_map_capability(udev, notify);
 507        priv->device = virtio_pci_map_capability(udev, device);
 508        debug("(%p): common @ %p, notify base @ %p, device @ %p\n",
 509              udev, priv->common, priv->notify_base, priv->device);
 510
 511        /* Read notify_off_multiplier from config space */
 512        offset = notify + offsetof(struct virtio_pci_notify_cap,
 513                                   notify_off_multiplier);
 514        dm_pci_read_config32(udev, offset, &priv->notify_offset_multiplier);
 515
 516        debug("(%s): device (%d) vendor (%08x) version (%d)\n", udev->name,
 517              uc_priv->device, uc_priv->vendor, revision);
 518
 519        return 0;
 520}
 521
 522static const struct dm_virtio_ops virtio_pci_ops = {
 523        .get_config     = virtio_pci_get_config,
 524        .set_config     = virtio_pci_set_config,
 525        .generation     = virtio_pci_generation,
 526        .get_status     = virtio_pci_get_status,
 527        .set_status     = virtio_pci_set_status,
 528        .reset          = virtio_pci_reset,
 529        .get_features   = virtio_pci_get_features,
 530        .set_features   = virtio_pci_set_features,
 531        .find_vqs       = virtio_pci_find_vqs,
 532        .del_vqs        = virtio_pci_del_vqs,
 533        .notify         = virtio_pci_notify,
 534};
 535
 536U_BOOT_DRIVER(virtio_pci_modern) = {
 537        .name   = VIRTIO_PCI_DRV_NAME,
 538        .id     = UCLASS_VIRTIO,
 539        .ops    = &virtio_pci_ops,
 540        .bind   = virtio_pci_bind,
 541        .probe  = virtio_pci_probe,
 542        .priv_auto      = sizeof(struct virtio_pci_priv),
 543};
 544
 545static struct pci_device_id virtio_pci_supported[] = {
 546        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID00) },
 547        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID01) },
 548        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID02) },
 549        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID03) },
 550        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID04) },
 551        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID05) },
 552        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID06) },
 553        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID07) },
 554        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID08) },
 555        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID09) },
 556        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0A) },
 557        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0B) },
 558        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0C) },
 559        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0D) },
 560        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0E) },
 561        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0F) },
 562        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID10) },
 563        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID11) },
 564        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID12) },
 565        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID13) },
 566        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID14) },
 567        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID15) },
 568        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID16) },
 569        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID17) },
 570        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID18) },
 571        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID19) },
 572        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1A) },
 573        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1B) },
 574        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1C) },
 575        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1D) },
 576        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1E) },
 577        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1F) },
 578        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID20) },
 579        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID21) },
 580        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID22) },
 581        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID23) },
 582        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID24) },
 583        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID25) },
 584        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID26) },
 585        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID27) },
 586        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID28) },
 587        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID29) },
 588        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2A) },
 589        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2B) },
 590        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2C) },
 591        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2D) },
 592        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2E) },
 593        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2F) },
 594        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID30) },
 595        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID31) },
 596        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID32) },
 597        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID33) },
 598        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID34) },
 599        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID35) },
 600        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID36) },
 601        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID37) },
 602        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID38) },
 603        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID39) },
 604        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3A) },
 605        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3B) },
 606        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3C) },
 607        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3D) },
 608        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3E) },
 609        { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3F) },
 610        {},
 611};
 612
 613U_BOOT_PCI_DEVICE(virtio_pci_modern, virtio_pci_supported);
 614
Hosted by Missing Link Electronics. The original LXR software by the LXR community, this experimental version by lxr@linux.no.