drivers/virtio/virtio_pci_legacy.c

   1 /*
   2  * Virtio PCI driver - legacy device support
   3  *
   4  * This module allows virtio devices to be used over a virtual PCI device.
   5  * This can be used with QEMU based VMMs like KVM or Xen.
   6  *
   7  * Copyright IBM Corp. 2007
   8  * Copyright Red Hat, Inc. 2014
   9  *
  10  * Authors:
  11  *  Anthony Liguori  <aliguori@us.ibm.com>
  12  *  Rusty Russell <rusty@rustcorp.com.au>
  13  *  Michael S. Tsirkin <mst@redhat.com>
  14  *
  15  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  16  * See the COPYING file in the top-level directory.
  17  *
  18  */
  19
  20 #include "virtio_pci_common.h"
  21
  22 /* Qumranet donated their vendor ID for devices 0x1000 thru 0x10FF. */
  23 static const struct pci_device_id virtio_pci_id_table[] = {
  24         { PCI_DEVICE(0x1af4, PCI_ANY_ID) },
  25         { 0 }
  26 };
  27
  28 MODULE_DEVICE_TABLE(pci, virtio_pci_id_table);
  29
  30 /* virtio config->get_features() implementation */
  31 static u64 vp_get_features(struct virtio_device *vdev)
  32 {
  33         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  34
  35         /* When someone needs more than 32 feature bits, we'll need to
  36          * steal a bit to indicate that the rest are somewhere else. */
  37         return ioread32(vp_dev->ioaddr + VIRTIO_PCI_HOST_FEATURES);
  38 }
  39
  40 /* virtio config->finalize_features() implementation */
  41 static int vp_finalize_features(struct virtio_device *vdev)
  42 {
  43         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  44
  45         /* Give virtio_ring a chance to accept features. */
  46         vring_transport_features(vdev);
  47
  48         /* Make sure we don't have any features > 32 bits! */
  49         BUG_ON((u32)vdev->features != vdev->features);
  50
  51         /* We only support 32 feature bits. */
  52         iowrite32(vdev->features, vp_dev->ioaddr + VIRTIO_PCI_GUEST_FEATURES);
  53
  54         return 0;
  55 }
  56
  57 /* virtio config->get() implementation */
  58 static void vp_get(struct virtio_device *vdev, unsigned offset,
  59                    void *buf, unsigned len)
  60 {
  61         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  62         void __iomem *ioaddr = vp_dev->ioaddr +
  63                                 VIRTIO_PCI_CONFIG(vp_dev) + offset;
  64         u8 *ptr = buf;
  65         int i;
  66
  67         for (i = 0; i < len; i++)
  68                 ptr[i] = ioread8(ioaddr + i);
  69 }
  70
  71 /* the config->set() implementation.  it's symmetric to the config->get()
  72  * implementation */
  73 static void vp_set(struct virtio_device *vdev, unsigned offset,
  74                    const void *buf, unsigned len)
  75 {
  76         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  77         void __iomem *ioaddr = vp_dev->ioaddr +
  78                                 VIRTIO_PCI_CONFIG(vp_dev) + offset;
  79         const u8 *ptr = buf;
  80         int i;
  81
  82         for (i = 0; i < len; i++)
  83                 iowrite8(ptr[i], ioaddr + i);
  84 }
  85
  86 /* config->{get,set}_status() implementations */
  87 static u8 vp_get_status(struct virtio_device *vdev)
  88 {
  89         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  90         return ioread8(vp_dev->ioaddr + VIRTIO_PCI_STATUS);
  91 }
  92
  93 static void vp_set_status(struct virtio_device *vdev, u8 status)
  94 {
  95         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  96         /* We should never be setting status to 0. */
  97         BUG_ON(status == 0);
  98         iowrite8(status, vp_dev->ioaddr + VIRTIO_PCI_STATUS);
  99 }
 100
 101 static void vp_reset(struct virtio_device *vdev)
 102 {
 103         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
 104         /* 0 status means a reset. */
 105         iowrite8(0, vp_dev->ioaddr + VIRTIO_PCI_STATUS);
 106         /* Flush out the status write, and flush in device writes,
 107          * including MSi-X interrupts, if any. */
 108         ioread8(vp_dev->ioaddr + VIRTIO_PCI_STATUS);
 109         /* Flush pending VQ/configuration callbacks. */
 110         vp_synchronize_vectors(vdev);
 111 }
 112
 113 static u16 vp_config_vector(struct virtio_pci_device *vp_dev, u16 vector)
 114 {
 115         /* Setup the vector used for configuration events */
 116         iowrite16(vector, vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR);
 117         /* Verify we had enough resources to assign the vector */
 118         /* Will also flush the write out to device */
 119         return ioread16(vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR);
 120 }
 121
 122 static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
 123                                   struct virtio_pci_vq_info *info,
 124                                   unsigned index,
 125                                   void (*callback)(struct virtqueue *vq),
 126                                   const char *name,
 127                                   u16 msix_vec)
 128 {
 129         struct virtqueue *vq;
 130         unsigned long size;
 131         u16 num;
 132         int err;
 133
 134         /* Select the queue we're interested in */
 135         iowrite16(index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_SEL);
 136
 137         /* Check if queue is either not available or already active. */
 138         num = ioread16(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_NUM);
 139         if (!num || ioread32(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN))
 140                 return ERR_PTR(-ENOENT);
 141
 142         info->num = num;
 143         info->msix_vector = msix_vec;
 144
 145         size = PAGE_ALIGN(vring_size(num, VIRTIO_PCI_VRING_ALIGN));
 146         info->queue = alloc_pages_exact(size, GFP_KERNEL|__GFP_ZERO);
 147         if (info->queue == NULL)
 148                 return ERR_PTR(-ENOMEM);
 149
 150         /* activate the queue */
 151         iowrite32(virt_to_phys(info->queue) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT,
 152                   vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
 153
 154         /* create the vring */
 155         vq = vring_new_virtqueue(index, info->num,
 156                                  VIRTIO_PCI_VRING_ALIGN, &vp_dev->vdev,
 157                                  true, info->queue, vp_notify, callback, name);
 158         if (!vq) {
 159                 err = -ENOMEM;
 160                 goto out_activate_queue;
 161         }
 162
 163         vq->priv = (void __force *)vp_dev->ioaddr + VIRTIO_PCI_QUEUE_NOTIFY;
 164
 165         if (msix_vec != VIRTIO_MSI_NO_VECTOR) {
 166                 iowrite16(msix_vec, vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR);
 167                 msix_vec = ioread16(vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR);
 168                 if (msix_vec == VIRTIO_MSI_NO_VECTOR) {
 169                         err = -EBUSY;
 170                         goto out_assign;
 171                 }
 172         }
 173
 174         return vq;
 175
 176 out_assign:
 177         vring_del_virtqueue(vq);
 178 out_activate_queue:
 179         iowrite32(0, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
 180         free_pages_exact(info->queue, size);
 181         return ERR_PTR(err);
 182 }
 183
 184 static void del_vq(struct virtio_pci_vq_info *info)
 185 {
 186         struct virtqueue *vq = info->vq;
 187         struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
 188         unsigned long size;
 189
 190         iowrite16(vq->index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_SEL);
 191
 192         if (vp_dev->msix_enabled) {
 193                 iowrite16(VIRTIO_MSI_NO_VECTOR,
 194                           vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR);
 195                 /* Flush the write out to device */
 196                 ioread8(vp_dev->ioaddr + VIRTIO_PCI_ISR);
 197         }
 198
 199         vring_del_virtqueue(vq);
 200
 201         /* Select and deactivate the queue */
 202         iowrite32(0, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
 203
 204         size = PAGE_ALIGN(vring_size(info->num, VIRTIO_PCI_VRING_ALIGN));
 205         free_pages_exact(info->queue, size);
 206 }
 207
 208 static const struct virtio_config_ops virtio_pci_config_ops = {
 209         .get            = vp_get,
 210         .set            = vp_set,
 211         .get_status     = vp_get_status,
 212         .set_status     = vp_set_status,
 213         .reset          = vp_reset,
 214         .find_vqs       = vp_find_vqs,
 215         .del_vqs        = vp_del_vqs,
 216         .get_features   = vp_get_features,
 217         .finalize_features = vp_finalize_features,
 218         .bus_name       = vp_bus_name,
 219         .set_vq_affinity = vp_set_vq_affinity,
 220 };
 221
 222 /* the PCI probing function */
 223 static int virtio_pci_probe(struct pci_dev *pci_dev,
 224                             const struct pci_device_id *id)
 225 {
 226         struct virtio_pci_device *vp_dev;
 227         int err;
 228
 229         /* We only own devices >= 0x1000 and <= 0x103f: leave the rest. */
 230         if (pci_dev->device < 0x1000 || pci_dev->device > 0x103f)
 231                 return -ENODEV;
 232
 233         if (pci_dev->revision != VIRTIO_PCI_ABI_VERSION) {
 234                 printk(KERN_ERR "virtio_pci: expected ABI version %d, got %d\n",
 235                        VIRTIO_PCI_ABI_VERSION, pci_dev->revision);
 236                 return -ENODEV;
 237         }
 238
 239         /* allocate our structure and fill it out */
 240         vp_dev = kzalloc(sizeof(struct virtio_pci_device), GFP_KERNEL);
 241         if (vp_dev == NULL)
 242                 return -ENOMEM;
 243
 244         vp_dev->vdev.dev.parent = &pci_dev->dev;
 245         vp_dev->vdev.dev.release = virtio_pci_release_dev;
 246         vp_dev->vdev.config = &virtio_pci_config_ops;
 247         vp_dev->pci_dev = pci_dev;
 248         INIT_LIST_HEAD(&vp_dev->virtqueues);
 249         spin_lock_init(&vp_dev->lock);
 250
 251         /* Disable MSI/MSIX to bring device to a known good state. */
 252         pci_msi_off(pci_dev);
 253
 254         /* enable the device */
 255         err = pci_enable_device(pci_dev);
 256         if (err)
 257                 goto out;
 258
 259         err = pci_request_regions(pci_dev, "virtio-pci");
 260         if (err)
 261                 goto out_enable_device;
 262
 263         vp_dev->ioaddr = pci_iomap(pci_dev, 0, 0);
 264         if (vp_dev->ioaddr == NULL) {
 265                 err = -ENOMEM;
 266                 goto out_req_regions;
 267         }
 268
 269         vp_dev->isr = vp_dev->ioaddr + VIRTIO_PCI_ISR;
 270
 271         pci_set_drvdata(pci_dev, vp_dev);
 272         pci_set_master(pci_dev);
 273
 274         /* we use the subsystem vendor/device id as the virtio vendor/device
 275          * id.  this allows us to use the same PCI vendor/device id for all
 276          * virtio devices and to identify the particular virtio driver by
 277          * the subsystem ids */
 278         vp_dev->vdev.id.vendor = pci_dev->subsystem_vendor;
 279         vp_dev->vdev.id.device = pci_dev->subsystem_device;
 280
 281         vp_dev->config_vector = vp_config_vector;
 282         vp_dev->setup_vq = setup_vq;
 283         vp_dev->del_vq = del_vq;
 284
 285         /* finally register the virtio device */
 286         err = register_virtio_device(&vp_dev->vdev);
 287         if (err)
 288                 goto out_set_drvdata;
 289
 290         return 0;
 291
 292 out_set_drvdata:
 293         pci_iounmap(pci_dev, vp_dev->ioaddr);
 294 out_req_regions:
 295         pci_release_regions(pci_dev);
 296 out_enable_device:
 297         pci_disable_device(pci_dev);
 298 out:
 299         kfree(vp_dev);
 300         return err;
 301 }
 302
 303 static void virtio_pci_remove(struct pci_dev *pci_dev)
 304 {
 305         struct virtio_pci_device *vp_dev = pci_get_drvdata(pci_dev);
 306
 307         unregister_virtio_device(&vp_dev->vdev);
 308
 309         vp_del_vqs(&vp_dev->vdev);
 310         pci_iounmap(pci_dev, vp_dev->ioaddr);
 311         pci_release_regions(pci_dev);
 312         pci_disable_device(pci_dev);
 313         kfree(vp_dev);
 314 }
 315
 316 static struct pci_driver virtio_pci_driver = {
 317         .name           = "virtio-pci",
 318         .id_table       = virtio_pci_id_table,
 319         .probe          = virtio_pci_probe,
 320         .remove         = virtio_pci_remove,
 321 #ifdef CONFIG_PM_SLEEP
 322         .driver.pm      = &virtio_pci_pm_ops,
 323 #endif
 324 };
 325
 326 module_pci_driver(virtio_pci_driver);