drivers/virtio/virtio_pci_legacy.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Virtio PCI driver - legacy device support
   4  *
   5  * This module allows virtio devices to be used over a virtual PCI device.
   6  * This can be used with QEMU based VMMs like KVM or Xen.
   7  *
   8  * Copyright IBM Corp. 2007
   9  * Copyright Red Hat, Inc. 2014
  10  *
  11  * Authors:
  12  *  Anthony Liguori  <aliguori@us.ibm.com>
  13  *  Rusty Russell <rusty@rustcorp.com.au>
  14  *  Michael S. Tsirkin <mst@redhat.com>
  15  */
  16
  17 #include "linux/virtio_pci_legacy.h"
  18 #include "virtio_pci_common.h"
  19
  20 /* virtio config->get_features() implementation */
  21 static u64 vp_get_features(struct virtio_device *vdev)
  22 {
  23         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  24
  25         /* When someone needs more than 32 feature bits, we'll need to
  26          * steal a bit to indicate that the rest are somewhere else. */
  27         return vp_legacy_get_features(&vp_dev->ldev);
  28 }
  29
  30 /* virtio config->finalize_features() implementation */
  31 static int vp_finalize_features(struct virtio_device *vdev)
  32 {
  33         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  34
  35         /* Give virtio_ring a chance to accept features. */
  36         vring_transport_features(vdev);
  37
  38         /* Make sure we don't have any features > 32 bits! */
  39         BUG_ON((u32)vdev->features != vdev->features);
  40
  41         /* We only support 32 feature bits. */
  42         vp_legacy_set_features(&vp_dev->ldev, vdev->features);
  43
  44         return 0;
  45 }
  46
  47 /* virtio config->get() implementation */
  48 static void vp_get(struct virtio_device *vdev, unsigned int offset,
  49                    void *buf, unsigned int len)
  50 {
  51         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  52         void __iomem *ioaddr = vp_dev->ldev.ioaddr +
  53                         VIRTIO_PCI_CONFIG_OFF(vp_dev->msix_enabled) +
  54                         offset;
  55         u8 *ptr = buf;
  56         int i;
  57
  58         for (i = 0; i < len; i++)
  59                 ptr[i] = ioread8(ioaddr + i);
  60 }
  61
  62 /* the config->set() implementation.  it's symmetric to the config->get()
  63  * implementation */
  64 static void vp_set(struct virtio_device *vdev, unsigned int offset,
  65                    const void *buf, unsigned int len)
  66 {
  67         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  68         void __iomem *ioaddr = vp_dev->ldev.ioaddr +
  69                         VIRTIO_PCI_CONFIG_OFF(vp_dev->msix_enabled) +
  70                         offset;
  71         const u8 *ptr = buf;
  72         int i;
  73
  74         for (i = 0; i < len; i++)
  75                 iowrite8(ptr[i], ioaddr + i);
  76 }
  77
  78 /* config->{get,set}_status() implementations */
  79 static u8 vp_get_status(struct virtio_device *vdev)
  80 {
  81         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  82         return vp_legacy_get_status(&vp_dev->ldev);
  83 }
  84
  85 static void vp_set_status(struct virtio_device *vdev, u8 status)
  86 {
  87         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  88         /* We should never be setting status to 0. */
  89         BUG_ON(status == 0);
  90         vp_legacy_set_status(&vp_dev->ldev, status);
  91 }
  92
  93 static void vp_reset(struct virtio_device *vdev)
  94 {
  95         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  96         /* 0 status means a reset. */
  97         vp_legacy_set_status(&vp_dev->ldev, 0);
  98         /* Flush out the status write, and flush in device writes,
  99          * including MSi-X interrupts, if any. */
 100         vp_legacy_get_status(&vp_dev->ldev);
 101         /* Flush pending VQ/configuration callbacks. */
 102         vp_synchronize_vectors(vdev);
 103 }
 104
 105 static u16 vp_config_vector(struct virtio_pci_device *vp_dev, u16 vector)
 106 {
 107         return vp_legacy_config_vector(&vp_dev->ldev, vector);
 108 }
 109
 110 static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
 111                                   struct virtio_pci_vq_info *info,
 112                                   unsigned int index,
 113                                   void (*callback)(struct virtqueue *vq),
 114                                   const char *name,
 115                                   u32 size,
 116                                   bool ctx,
 117                                   u16 msix_vec)
 118 {
 119         struct virtqueue *vq;
 120         u16 num;
 121         int err;
 122         u64 q_pfn;
 123
 124         /* Check if queue is either not available or already active. */
 125         num = vp_legacy_get_queue_size(&vp_dev->ldev, index);
 126         if (!num || vp_legacy_get_queue_enable(&vp_dev->ldev, index))
 127                 return ERR_PTR(-ENOENT);
 128
 129         if (!size || size > num)
 130                 size = num;
 131
 132         info->msix_vector = msix_vec;
 133
 134         /* create the vring */
 135         vq = vring_create_virtqueue(index, size,
 136                                     VIRTIO_PCI_VRING_ALIGN, &vp_dev->vdev,
 137                                     true, false, ctx,
 138                                     vp_notify, callback, name);
 139         if (!vq)
 140                 return ERR_PTR(-ENOMEM);
 141
 142         vq->num_max = num;
 143
 144         q_pfn = virtqueue_get_desc_addr(vq) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT;
 145         if (q_pfn >> 32) {
 146                 dev_err(&vp_dev->pci_dev->dev,
 147                         "platform bug: legacy virtio-pci must not be used with RAM above 0x%llxGB\n",
 148                         0x1ULL << (32 + PAGE_SHIFT - 30));
 149                 err = -E2BIG;
 150                 goto out_del_vq;
 151         }
 152
 153         /* activate the queue */
 154         vp_legacy_set_queue_address(&vp_dev->ldev, index, q_pfn);
 155
 156         vq->priv = (void __force *)vp_dev->ldev.ioaddr + VIRTIO_PCI_QUEUE_NOTIFY;
 157
 158         if (msix_vec != VIRTIO_MSI_NO_VECTOR) {
 159                 msix_vec = vp_legacy_queue_vector(&vp_dev->ldev, index, msix_vec);
 160                 if (msix_vec == VIRTIO_MSI_NO_VECTOR) {
 161                         err = -EBUSY;
 162                         goto out_deactivate;
 163                 }
 164         }
 165
 166         return vq;
 167
 168 out_deactivate:
 169         vp_legacy_set_queue_address(&vp_dev->ldev, index, 0);
 170 out_del_vq:
 171         vring_del_virtqueue(vq);
 172         return ERR_PTR(err);
 173 }
 174
 175 static void del_vq(struct virtio_pci_vq_info *info)
 176 {
 177         struct virtqueue *vq = info->vq;
 178         struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
 179
 180         if (vp_dev->msix_enabled) {
 181                 vp_legacy_queue_vector(&vp_dev->ldev, vq->index,
 182                                 VIRTIO_MSI_NO_VECTOR);
 183                 /* Flush the write out to device */
 184                 ioread8(vp_dev->ldev.ioaddr + VIRTIO_PCI_ISR);
 185         }
 186
 187         /* Select and deactivate the queue */
 188         vp_legacy_set_queue_address(&vp_dev->ldev, vq->index, 0);
 189
 190         vring_del_virtqueue(vq);
 191 }
 192
 193 static const struct virtio_config_ops virtio_pci_config_ops = {
 194         .get            = vp_get,
 195         .set            = vp_set,
 196         .get_status     = vp_get_status,
 197         .set_status     = vp_set_status,
 198         .reset          = vp_reset,
 199         .find_vqs       = vp_find_vqs,
 200         .del_vqs        = vp_del_vqs,
 201         .synchronize_cbs = vp_synchronize_vectors,
 202         .get_features   = vp_get_features,
 203         .finalize_features = vp_finalize_features,
 204         .bus_name       = vp_bus_name,
 205         .set_vq_affinity = vp_set_vq_affinity,
 206         .get_vq_affinity = vp_get_vq_affinity,
 207 };
 208
 209 /* the PCI probing function */
 210 int virtio_pci_legacy_probe(struct virtio_pci_device *vp_dev)
 211 {
 212         struct virtio_pci_legacy_device *ldev = &vp_dev->ldev;
 213         struct pci_dev *pci_dev = vp_dev->pci_dev;
 214         int rc;
 215
 216         ldev->pci_dev = pci_dev;
 217
 218         rc = vp_legacy_probe(ldev);
 219         if (rc)
 220                 return rc;
 221
 222         vp_dev->isr = ldev->isr;
 223         vp_dev->vdev.id = ldev->id;
 224
 225         vp_dev->vdev.config = &virtio_pci_config_ops;
 226
 227         vp_dev->config_vector = vp_config_vector;
 228         vp_dev->setup_vq = setup_vq;
 229         vp_dev->del_vq = del_vq;
 230
 231         return 0;
 232 }
 233
 234 void virtio_pci_legacy_remove(struct virtio_pci_device *vp_dev)
 235 {
 236         struct virtio_pci_legacy_device *ldev = &vp_dev->ldev;
 237
 238         vp_legacy_remove(ldev);
 239 }