linux/drivers/virtio/virtio_pci.c
<<
>>
Prefs
   1/*
   2 * Virtio PCI driver
   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 *
   9 * Authors:
  10 *  Anthony Liguori  <aliguori@us.ibm.com>
  11 *
  12 * This work is licensed under the terms of the GNU GPL, version 2 or later.
  13 * See the COPYING file in the top-level directory.
  14 *
  15 */
  16
  17#include <linux/module.h>
  18#include <linux/list.h>
  19#include <linux/pci.h>
  20#include <linux/interrupt.h>
  21#include <linux/virtio.h>
  22#include <linux/virtio_config.h>
  23#include <linux/virtio_ring.h>
  24#include <linux/virtio_pci.h>
  25#include <linux/highmem.h>
  26#include <linux/spinlock.h>
  27
  28MODULE_AUTHOR("Anthony Liguori <aliguori@us.ibm.com>");
  29MODULE_DESCRIPTION("virtio-pci");
  30MODULE_LICENSE("GPL");
  31MODULE_VERSION("1");
  32
  33/* Our device structure */
  34struct virtio_pci_device
  35{
  36        struct virtio_device vdev;
  37        struct pci_dev *pci_dev;
  38
  39        /* the IO mapping for the PCI config space */
  40        void __iomem *ioaddr;
  41
  42        /* a list of queues so we can dispatch IRQs */
  43        spinlock_t lock;
  44        struct list_head virtqueues;
  45};
  46
  47struct virtio_pci_vq_info
  48{
  49        /* the actual virtqueue */
  50        struct virtqueue *vq;
  51
  52        /* the number of entries in the queue */
  53        int num;
  54
  55        /* the index of the queue */
  56        int queue_index;
  57
  58        /* the virtual address of the ring queue */
  59        void *queue;
  60
  61        /* the list node for the virtqueues list */
  62        struct list_head node;
  63};
  64
  65/* Qumranet donated their vendor ID for devices 0x1000 thru 0x10FF. */
  66static struct pci_device_id virtio_pci_id_table[] = {
  67        { 0x1af4, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
  68        { 0 },
  69};
  70
  71MODULE_DEVICE_TABLE(pci, virtio_pci_id_table);
  72
  73/* A PCI device has it's own struct device and so does a virtio device so
  74 * we create a place for the virtio devices to show up in sysfs.  I think it
  75 * would make more sense for virtio to not insist on having it's own device. */
  76static struct device virtio_pci_root = {
  77        .parent         = NULL,
  78        .bus_id         = "virtio-pci",
  79};
  80
  81/* Convert a generic virtio device to our structure */
  82static struct virtio_pci_device *to_vp_device(struct virtio_device *vdev)
  83{
  84        return container_of(vdev, struct virtio_pci_device, vdev);
  85}
  86
  87/* virtio config->get_features() implementation */
  88static u32 vp_get_features(struct virtio_device *vdev)
  89{
  90        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  91
  92        /* When someone needs more than 32 feature bits, we'll need to
  93         * steal a bit to indicate that the rest are somewhere else. */
  94        return ioread32(vp_dev->ioaddr + VIRTIO_PCI_HOST_FEATURES);
  95}
  96
  97/* virtio config->finalize_features() implementation */
  98static void vp_finalize_features(struct virtio_device *vdev)
  99{
 100        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
 101
 102        /* Give virtio_ring a chance to accept features. */
 103        vring_transport_features(vdev);
 104
 105        /* We only support 32 feature bits. */
 106        BUILD_BUG_ON(ARRAY_SIZE(vdev->features) != 1);
 107        iowrite32(vdev->features[0], vp_dev->ioaddr+VIRTIO_PCI_GUEST_FEATURES);
 108}
 109
 110/* virtio config->get() implementation */
 111static void vp_get(struct virtio_device *vdev, unsigned offset,
 112                   void *buf, unsigned len)
 113{
 114        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
 115        void __iomem *ioaddr = vp_dev->ioaddr + VIRTIO_PCI_CONFIG + offset;
 116        u8 *ptr = buf;
 117        int i;
 118
 119        for (i = 0; i < len; i++)
 120                ptr[i] = ioread8(ioaddr + i);
 121}
 122
 123/* the config->set() implementation.  it's symmetric to the config->get()
 124 * implementation */
 125static void vp_set(struct virtio_device *vdev, unsigned offset,
 126                   const void *buf, unsigned len)
 127{
 128        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
 129        void __iomem *ioaddr = vp_dev->ioaddr + VIRTIO_PCI_CONFIG + offset;
 130        const u8 *ptr = buf;
 131        int i;
 132
 133        for (i = 0; i < len; i++)
 134                iowrite8(ptr[i], ioaddr + i);
 135}
 136
 137/* config->{get,set}_status() implementations */
 138static u8 vp_get_status(struct virtio_device *vdev)
 139{
 140        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
 141        return ioread8(vp_dev->ioaddr + VIRTIO_PCI_STATUS);
 142}
 143
 144static void vp_set_status(struct virtio_device *vdev, u8 status)
 145{
 146        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
 147        /* We should never be setting status to 0. */
 148        BUG_ON(status == 0);
 149        iowrite8(status, vp_dev->ioaddr + VIRTIO_PCI_STATUS);
 150}
 151
 152static void vp_reset(struct virtio_device *vdev)
 153{
 154        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
 155        /* 0 status means a reset. */
 156        iowrite8(0, vp_dev->ioaddr + VIRTIO_PCI_STATUS);
 157}
 158
 159/* the notify function used when creating a virt queue */
 160static void vp_notify(struct virtqueue *vq)
 161{
 162        struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
 163        struct virtio_pci_vq_info *info = vq->priv;
 164
 165        /* we write the queue's selector into the notification register to
 166         * signal the other end */
 167        iowrite16(info->queue_index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_NOTIFY);
 168}
 169
 170/* A small wrapper to also acknowledge the interrupt when it's handled.
 171 * I really need an EIO hook for the vring so I can ack the interrupt once we
 172 * know that we'll be handling the IRQ but before we invoke the callback since
 173 * the callback may notify the host which results in the host attempting to
 174 * raise an interrupt that we would then mask once we acknowledged the
 175 * interrupt. */
 176static irqreturn_t vp_interrupt(int irq, void *opaque)
 177{
 178        struct virtio_pci_device *vp_dev = opaque;
 179        struct virtio_pci_vq_info *info;
 180        irqreturn_t ret = IRQ_NONE;
 181        unsigned long flags;
 182        u8 isr;
 183
 184        /* reading the ISR has the effect of also clearing it so it's very
 185         * important to save off the value. */
 186        isr = ioread8(vp_dev->ioaddr + VIRTIO_PCI_ISR);
 187
 188        /* It's definitely not us if the ISR was not high */
 189        if (!isr)
 190                return IRQ_NONE;
 191
 192        /* Configuration change?  Tell driver if it wants to know. */
 193        if (isr & VIRTIO_PCI_ISR_CONFIG) {
 194                struct virtio_driver *drv;
 195                drv = container_of(vp_dev->vdev.dev.driver,
 196                                   struct virtio_driver, driver);
 197
 198                if (drv->config_changed)
 199                        drv->config_changed(&vp_dev->vdev);
 200        }
 201
 202        spin_lock_irqsave(&vp_dev->lock, flags);
 203        list_for_each_entry(info, &vp_dev->virtqueues, node) {
 204                if (vring_interrupt(irq, info->vq) == IRQ_HANDLED)
 205                        ret = IRQ_HANDLED;
 206        }
 207        spin_unlock_irqrestore(&vp_dev->lock, flags);
 208
 209        return ret;
 210}
 211
 212/* the config->find_vq() implementation */
 213static struct virtqueue *vp_find_vq(struct virtio_device *vdev, unsigned index,
 214                                    void (*callback)(struct virtqueue *vq))
 215{
 216        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
 217        struct virtio_pci_vq_info *info;
 218        struct virtqueue *vq;
 219        unsigned long flags;
 220        u16 num;
 221        int err;
 222
 223        /* Select the queue we're interested in */
 224        iowrite16(index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_SEL);
 225
 226        /* Check if queue is either not available or already active. */
 227        num = ioread16(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_NUM);
 228        if (!num || ioread32(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN))
 229                return ERR_PTR(-ENOENT);
 230
 231        /* allocate and fill out our structure the represents an active
 232         * queue */
 233        info = kmalloc(sizeof(struct virtio_pci_vq_info), GFP_KERNEL);
 234        if (!info)
 235                return ERR_PTR(-ENOMEM);
 236
 237        info->queue_index = index;
 238        info->num = num;
 239
 240        info->queue = kzalloc(PAGE_ALIGN(vring_size(num,PAGE_SIZE)), GFP_KERNEL);
 241        if (info->queue == NULL) {
 242                err = -ENOMEM;
 243                goto out_info;
 244        }
 245
 246        /* activate the queue */
 247        iowrite32(virt_to_phys(info->queue) >> PAGE_SHIFT,
 248                  vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
 249
 250        /* create the vring */
 251        vq = vring_new_virtqueue(info->num, vdev, info->queue,
 252                                 vp_notify, callback);
 253        if (!vq) {
 254                err = -ENOMEM;
 255                goto out_activate_queue;
 256        }
 257
 258        vq->priv = info;
 259        info->vq = vq;
 260
 261        spin_lock_irqsave(&vp_dev->lock, flags);
 262        list_add(&info->node, &vp_dev->virtqueues);
 263        spin_unlock_irqrestore(&vp_dev->lock, flags);
 264
 265        return vq;
 266
 267out_activate_queue:
 268        iowrite32(0, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
 269        kfree(info->queue);
 270out_info:
 271        kfree(info);
 272        return ERR_PTR(err);
 273}
 274
 275/* the config->del_vq() implementation */
 276static void vp_del_vq(struct virtqueue *vq)
 277{
 278        struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
 279        struct virtio_pci_vq_info *info = vq->priv;
 280        unsigned long flags;
 281
 282        spin_lock_irqsave(&vp_dev->lock, flags);
 283        list_del(&info->node);
 284        spin_unlock_irqrestore(&vp_dev->lock, flags);
 285
 286        vring_del_virtqueue(vq);
 287
 288        /* Select and deactivate the queue */
 289        iowrite16(info->queue_index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_SEL);
 290        iowrite32(0, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
 291
 292        kfree(info->queue);
 293        kfree(info);
 294}
 295
 296static struct virtio_config_ops virtio_pci_config_ops = {
 297        .get            = vp_get,
 298        .set            = vp_set,
 299        .get_status     = vp_get_status,
 300        .set_status     = vp_set_status,
 301        .reset          = vp_reset,
 302        .find_vq        = vp_find_vq,
 303        .del_vq         = vp_del_vq,
 304        .get_features   = vp_get_features,
 305        .finalize_features = vp_finalize_features,
 306};
 307
 308/* the PCI probing function */
 309static int __devinit virtio_pci_probe(struct pci_dev *pci_dev,
 310                                      const struct pci_device_id *id)
 311{
 312        struct virtio_pci_device *vp_dev;
 313        int err;
 314
 315        /* We only own devices >= 0x1000 and <= 0x103f: leave the rest. */
 316        if (pci_dev->device < 0x1000 || pci_dev->device > 0x103f)
 317                return -ENODEV;
 318
 319        if (pci_dev->revision != VIRTIO_PCI_ABI_VERSION) {
 320                printk(KERN_ERR "virtio_pci: expected ABI version %d, got %d\n",
 321                       VIRTIO_PCI_ABI_VERSION, pci_dev->revision);
 322                return -ENODEV;
 323        }
 324
 325        /* allocate our structure and fill it out */
 326        vp_dev = kzalloc(sizeof(struct virtio_pci_device), GFP_KERNEL);
 327        if (vp_dev == NULL)
 328                return -ENOMEM;
 329
 330        vp_dev->vdev.dev.parent = &virtio_pci_root;
 331        vp_dev->vdev.config = &virtio_pci_config_ops;
 332        vp_dev->pci_dev = pci_dev;
 333        INIT_LIST_HEAD(&vp_dev->virtqueues);
 334        spin_lock_init(&vp_dev->lock);
 335
 336        /* enable the device */
 337        err = pci_enable_device(pci_dev);
 338        if (err)
 339                goto out;
 340
 341        err = pci_request_regions(pci_dev, "virtio-pci");
 342        if (err)
 343                goto out_enable_device;
 344
 345        vp_dev->ioaddr = pci_iomap(pci_dev, 0, 0);
 346        if (vp_dev->ioaddr == NULL)
 347                goto out_req_regions;
 348
 349        pci_set_drvdata(pci_dev, vp_dev);
 350
 351        /* we use the subsystem vendor/device id as the virtio vendor/device
 352         * id.  this allows us to use the same PCI vendor/device id for all
 353         * virtio devices and to identify the particular virtio driver by
 354         * the subsytem ids */
 355        vp_dev->vdev.id.vendor = pci_dev->subsystem_vendor;
 356        vp_dev->vdev.id.device = pci_dev->subsystem_device;
 357
 358        /* register a handler for the queue with the PCI device's interrupt */
 359        err = request_irq(vp_dev->pci_dev->irq, vp_interrupt, IRQF_SHARED,
 360                          vp_dev->vdev.dev.bus_id, vp_dev);
 361        if (err)
 362                goto out_set_drvdata;
 363
 364        /* finally register the virtio device */
 365        err = register_virtio_device(&vp_dev->vdev);
 366        if (err)
 367                goto out_req_irq;
 368
 369        return 0;
 370
 371out_req_irq:
 372        free_irq(pci_dev->irq, vp_dev);
 373out_set_drvdata:
 374        pci_set_drvdata(pci_dev, NULL);
 375        pci_iounmap(pci_dev, vp_dev->ioaddr);
 376out_req_regions:
 377        pci_release_regions(pci_dev);
 378out_enable_device:
 379        pci_disable_device(pci_dev);
 380out:
 381        kfree(vp_dev);
 382        return err;
 383}
 384
 385static void __devexit virtio_pci_remove(struct pci_dev *pci_dev)
 386{
 387        struct virtio_pci_device *vp_dev = pci_get_drvdata(pci_dev);
 388
 389        unregister_virtio_device(&vp_dev->vdev);
 390        free_irq(pci_dev->irq, vp_dev);
 391        pci_set_drvdata(pci_dev, NULL);
 392        pci_iounmap(pci_dev, vp_dev->ioaddr);
 393        pci_release_regions(pci_dev);
 394        pci_disable_device(pci_dev);
 395        kfree(vp_dev);
 396}
 397
 398#ifdef CONFIG_PM
 399static int virtio_pci_suspend(struct pci_dev *pci_dev, pm_message_t state)
 400{
 401        pci_save_state(pci_dev);
 402        pci_set_power_state(pci_dev, PCI_D3hot);
 403        return 0;
 404}
 405
 406static int virtio_pci_resume(struct pci_dev *pci_dev)
 407{
 408        pci_restore_state(pci_dev);
 409        pci_set_power_state(pci_dev, PCI_D0);
 410        return 0;
 411}
 412#endif
 413
 414static struct pci_driver virtio_pci_driver = {
 415        .name           = "virtio-pci",
 416        .id_table       = virtio_pci_id_table,
 417        .probe          = virtio_pci_probe,
 418        .remove         = virtio_pci_remove,
 419#ifdef CONFIG_PM
 420        .suspend        = virtio_pci_suspend,
 421        .resume         = virtio_pci_resume,
 422#endif
 423};
 424
 425static int __init virtio_pci_init(void)
 426{
 427        int err;
 428
 429        err = device_register(&virtio_pci_root);
 430        if (err)
 431                return err;
 432
 433        err = pci_register_driver(&virtio_pci_driver);
 434        if (err)
 435                device_unregister(&virtio_pci_root);
 436
 437        return err;
 438}
 439
 440module_init(virtio_pci_init);
 441
 442static void __exit virtio_pci_exit(void)
 443{
 444        device_unregister(&virtio_pci_root);
 445        pci_unregister_driver(&virtio_pci_driver);
 446}
 447
 448module_exit(virtio_pci_exit);
 449