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/slab.h> 21#include <linux/interrupt.h> 22#include <linux/virtio.h> 23#include <linux/virtio_config.h> 24#include <linux/virtio_ring.h> 25#include <linux/virtio_pci.h> 26#include <linux/highmem.h> 27#include <linux/spinlock.h> 28 29MODULE_AUTHOR("Anthony Liguori <aliguori@us.ibm.com>"); 30MODULE_DESCRIPTION("virtio-pci"); 31MODULE_LICENSE("GPL"); 32MODULE_VERSION("1"); 33 34/* Our device structure */ 35struct virtio_pci_device 36{ 37 struct virtio_device vdev; 38 struct pci_dev *pci_dev; 39 40 /* the IO mapping for the PCI config space */ 41 void __iomem *ioaddr; 42 43 /* a list of queues so we can dispatch IRQs */ 44 spinlock_t lock; 45 struct list_head virtqueues; 46 47 /* MSI-X support */ 48 int msix_enabled; 49 int intx_enabled; 50 struct msix_entry *msix_entries; 51 /* Name strings for interrupts. This size should be enough, 52 * and I'm too lazy to allocate each name separately. */ 53 char (*msix_names)[256]; 54 /* Number of available vectors */ 55 unsigned msix_vectors; 56 /* Vectors allocated, excluding per-vq vectors if any */ 57 unsigned msix_used_vectors; 58 /* Whether we have vector per vq */ 59 bool per_vq_vectors; 60}; 61 62/* Constants for MSI-X */ 63/* Use first vector for configuration changes, second and the rest for 64 * virtqueues Thus, we need at least 2 vectors for MSI. */ 65enum { 66 VP_MSIX_CONFIG_VECTOR = 0, 67 VP_MSIX_VQ_VECTOR = 1, 68}; 69 70struct virtio_pci_vq_info 71{ 72 /* the actual virtqueue */ 73 struct virtqueue *vq; 74 75 /* the number of entries in the queue */ 76 int num; 77 78 /* the index of the queue */ 79 int queue_index; 80 81 /* the virtual address of the ring queue */ 82 void *queue; 83 84 /* the list node for the virtqueues list */ 85 struct list_head node; 86 87 /* MSI-X vector (or none) */ 88 unsigned msix_vector; 89}; 90 91/* Qumranet donated their vendor ID for devices 0x1000 thru 0x10FF. */ 92static struct pci_device_id virtio_pci_id_table[] = { 93 { 0x1af4, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, 94 { 0 }, 95}; 96 97MODULE_DEVICE_TABLE(pci, virtio_pci_id_table); 98 99/* Convert a generic virtio device to our structure */ 100static struct virtio_pci_device *to_vp_device(struct virtio_device *vdev) 101{ 102 return container_of(vdev, struct virtio_pci_device, vdev); 103} 104 105/* virtio config->get_features() implementation */ 106static u32 vp_get_features(struct virtio_device *vdev) 107{ 108 struct virtio_pci_device *vp_dev = to_vp_device(vdev); 109 110 /* When someone needs more than 32 feature bits, we'll need to 111 * steal a bit to indicate that the rest are somewhere else. */ 112 return ioread32(vp_dev->ioaddr + VIRTIO_PCI_HOST_FEATURES); 113} 114 115/* virtio config->finalize_features() implementation */ 116static void vp_finalize_features(struct virtio_device *vdev) 117{ 118 struct virtio_pci_device *vp_dev = to_vp_device(vdev); 119 120 /* Give virtio_ring a chance to accept features. */ 121 vring_transport_features(vdev); 122 123 /* We only support 32 feature bits. */ 124 BUILD_BUG_ON(ARRAY_SIZE(vdev->features) != 1); 125 iowrite32(vdev->features[0], vp_dev->ioaddr+VIRTIO_PCI_GUEST_FEATURES); 126} 127 128/* virtio config->get() implementation */ 129static void vp_get(struct virtio_device *vdev, unsigned offset, 130 void *buf, unsigned len) 131{ 132 struct virtio_pci_device *vp_dev = to_vp_device(vdev); 133 void __iomem *ioaddr = vp_dev->ioaddr + 134 VIRTIO_PCI_CONFIG(vp_dev) + offset; 135 u8 *ptr = buf; 136 int i; 137 138 for (i = 0; i < len; i++) 139 ptr[i] = ioread8(ioaddr + i); 140} 141 142/* the config->set() implementation. it's symmetric to the config->get() 143 * implementation */ 144static void vp_set(struct virtio_device *vdev, unsigned offset, 145 const void *buf, unsigned len) 146{ 147 struct virtio_pci_device *vp_dev = to_vp_device(vdev); 148 void __iomem *ioaddr = vp_dev->ioaddr + 149 VIRTIO_PCI_CONFIG(vp_dev) + offset; 150 const u8 *ptr = buf; 151 int i; 152 153 for (i = 0; i < len; i++) 154 iowrite8(ptr[i], ioaddr + i); 155} 156 157/* config->{get,set}_status() implementations */ 158static u8 vp_get_status(struct virtio_device *vdev) 159{ 160 struct virtio_pci_device *vp_dev = to_vp_device(vdev); 161 return ioread8(vp_dev->ioaddr + VIRTIO_PCI_STATUS); 162} 163 164static void vp_set_status(struct virtio_device *vdev, u8 status) 165{ 166 struct virtio_pci_device *vp_dev = to_vp_device(vdev); 167 /* We should never be setting status to 0. */ 168 BUG_ON(status == 0); 169 iowrite8(status, vp_dev->ioaddr + VIRTIO_PCI_STATUS); 170} 171 172static void vp_reset(struct virtio_device *vdev) 173{ 174 struct virtio_pci_device *vp_dev = to_vp_device(vdev); 175 /* 0 status means a reset. */ 176 iowrite8(0, vp_dev->ioaddr + VIRTIO_PCI_STATUS); 177} 178 179/* the notify function used when creating a virt queue */ 180static void vp_notify(struct virtqueue *vq) 181{ 182 struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev); 183 struct virtio_pci_vq_info *info = vq->priv; 184 185 /* we write the queue's selector into the notification register to 186 * signal the other end */ 187 iowrite16(info->queue_index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_NOTIFY); 188} 189 190/* Handle a configuration change: Tell driver if it wants to know. */ 191static irqreturn_t vp_config_changed(int irq, void *opaque) 192{ 193 struct virtio_pci_device *vp_dev = opaque; 194 struct virtio_driver *drv; 195 drv = container_of(vp_dev->vdev.dev.driver, 196 struct virtio_driver, driver); 197 198 if (drv && drv->config_changed) 199 drv->config_changed(&vp_dev->vdev); 200 return IRQ_HANDLED; 201} 202 203/* Notify all virtqueues on an interrupt. */ 204static irqreturn_t vp_vring_interrupt(int irq, void *opaque) 205{ 206 struct virtio_pci_device *vp_dev = opaque; 207 struct virtio_pci_vq_info *info; 208 irqreturn_t ret = IRQ_NONE; 209 unsigned long flags; 210 211 spin_lock_irqsave(&vp_dev->lock, flags); 212 list_for_each_entry(info, &vp_dev->virtqueues, node) { 213 if (vring_interrupt(irq, info->vq) == IRQ_HANDLED) 214 ret = IRQ_HANDLED; 215 } 216 spin_unlock_irqrestore(&vp_dev->lock, flags); 217 218 return ret; 219} 220 221/* A small wrapper to also acknowledge the interrupt when it's handled. 222 * I really need an EIO hook for the vring so I can ack the interrupt once we 223 * know that we'll be handling the IRQ but before we invoke the callback since 224 * the callback may notify the host which results in the host attempting to 225 * raise an interrupt that we would then mask once we acknowledged the 226 * interrupt. */ 227static irqreturn_t vp_interrupt(int irq, void *opaque) 228{ 229 struct virtio_pci_device *vp_dev = opaque; 230 u8 isr; 231 232 /* reading the ISR has the effect of also clearing it so it's very 233 * important to save off the value. */ 234 isr = ioread8(vp_dev->ioaddr + VIRTIO_PCI_ISR); 235 236 /* It's definitely not us if the ISR was not high */ 237 if (!isr) 238 return IRQ_NONE; 239 240 /* Configuration change? Tell driver if it wants to know. */ 241 if (isr & VIRTIO_PCI_ISR_CONFIG) 242 vp_config_changed(irq, opaque); 243 244 return vp_vring_interrupt(irq, opaque); 245} 246 247static void vp_free_vectors(struct virtio_device *vdev) 248{ 249 struct virtio_pci_device *vp_dev = to_vp_device(vdev); 250 int i; 251 252 if (vp_dev->intx_enabled) { 253 free_irq(vp_dev->pci_dev->irq, vp_dev); 254 vp_dev->intx_enabled = 0; 255 } 256 257 for (i = 0; i < vp_dev->msix_used_vectors; ++i) 258 free_irq(vp_dev->msix_entries[i].vector, vp_dev); 259 260 if (vp_dev->msix_enabled) { 261 /* Disable the vector used for configuration */ 262 iowrite16(VIRTIO_MSI_NO_VECTOR, 263 vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR); 264 /* Flush the write out to device */ 265 ioread16(vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR); 266 267 pci_disable_msix(vp_dev->pci_dev); 268 vp_dev->msix_enabled = 0; 269 vp_dev->msix_vectors = 0; 270 } 271 272 vp_dev->msix_used_vectors = 0; 273 kfree(vp_dev->msix_names); 274 vp_dev->msix_names = NULL; 275 kfree(vp_dev->msix_entries); 276 vp_dev->msix_entries = NULL; 277} 278 279static int vp_request_msix_vectors(struct virtio_device *vdev, int nvectors, 280 bool per_vq_vectors) 281{ 282 struct virtio_pci_device *vp_dev = to_vp_device(vdev); 283 const char *name = dev_name(&vp_dev->vdev.dev); 284 unsigned i, v; 285 int err = -ENOMEM; 286 287 vp_dev->msix_entries = kmalloc(nvectors * sizeof *vp_dev->msix_entries, 288 GFP_KERNEL); 289 if (!vp_dev->msix_entries) 290 goto error; 291 vp_dev->msix_names = kmalloc(nvectors * sizeof *vp_dev->msix_names, 292 GFP_KERNEL); 293 if (!vp_dev->msix_names) 294 goto error; 295 296 for (i = 0; i < nvectors; ++i) 297 vp_dev->msix_entries[i].entry = i; 298 299 /* pci_enable_msix returns positive if we can't get this many. */ 300 err = pci_enable_msix(vp_dev->pci_dev, vp_dev->msix_entries, nvectors); 301 if (err > 0) 302 err = -ENOSPC; 303 if (err) 304 goto error; 305 vp_dev->msix_vectors = nvectors; 306 vp_dev->msix_enabled = 1; 307 308 /* Set the vector used for configuration */ 309 v = vp_dev->msix_used_vectors; 310 snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names, 311 "%s-config", name); 312 err = request_irq(vp_dev->msix_entries[v].vector, 313 vp_config_changed, 0, vp_dev->msix_names[v], 314 vp_dev); 315 if (err) 316 goto error; 317 ++vp_dev->msix_used_vectors; 318 319 iowrite16(v, vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR); 320 /* Verify we had enough resources to assign the vector */ 321 v = ioread16(vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR); 322 if (v == VIRTIO_MSI_NO_VECTOR) { 323 err = -EBUSY; 324 goto error; 325 } 326 327 if (!per_vq_vectors) { 328 /* Shared vector for all VQs */ 329 v = vp_dev->msix_used_vectors; 330 snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names, 331 "%s-virtqueues", name); 332 err = request_irq(vp_dev->msix_entries[v].vector, 333 vp_vring_interrupt, 0, vp_dev->msix_names[v], 334 vp_dev); 335 if (err) 336 goto error; 337 ++vp_dev->msix_used_vectors; 338 } 339 return 0; 340error: 341 vp_free_vectors(vdev); 342 return err; 343} 344 345static int vp_request_intx(struct virtio_device *vdev) 346{ 347 int err; 348 struct virtio_pci_device *vp_dev = to_vp_device(vdev); 349 350 err = request_irq(vp_dev->pci_dev->irq, vp_interrupt, 351 IRQF_SHARED, dev_name(&vdev->dev), vp_dev); 352 if (!err) 353 vp_dev->intx_enabled = 1; 354 return err; 355} 356 357static struct virtqueue *setup_vq(struct virtio_device *vdev, unsigned index, 358 void (*callback)(struct virtqueue *vq), 359 const char *name, 360 u16 msix_vec) 361{ 362 struct virtio_pci_device *vp_dev = to_vp_device(vdev); 363 struct virtio_pci_vq_info *info; 364 struct virtqueue *vq; 365 unsigned long flags, size; 366 u16 num; 367 int err; 368 369 /* Select the queue we're interested in */ 370 iowrite16(index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_SEL); 371 372 /* Check if queue is either not available or already active. */ 373 num = ioread16(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_NUM); 374 if (!num || ioread32(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN)) 375 return ERR_PTR(-ENOENT); 376 377 /* allocate and fill out our structure the represents an active 378 * queue */ 379 info = kmalloc(sizeof(struct virtio_pci_vq_info), GFP_KERNEL); 380 if (!info) 381 return ERR_PTR(-ENOMEM); 382 383 info->queue_index = index; 384 info->num = num; 385 info->msix_vector = msix_vec; 386 387 size = PAGE_ALIGN(vring_size(num, VIRTIO_PCI_VRING_ALIGN)); 388 info->queue = alloc_pages_exact(size, GFP_KERNEL|__GFP_ZERO); 389 if (info->queue == NULL) { 390 err = -ENOMEM; 391 goto out_info; 392 } 393 394 /* activate the queue */ 395 iowrite32(virt_to_phys(info->queue) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT, 396 vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN); 397 398 /* create the vring */ 399 vq = vring_new_virtqueue(info->num, VIRTIO_PCI_VRING_ALIGN, 400 vdev, info->queue, vp_notify, callback, name); 401 if (!vq) { 402 err = -ENOMEM; 403 goto out_activate_queue; 404 } 405 406 vq->priv = info; 407 info->vq = vq; 408 409 if (msix_vec != VIRTIO_MSI_NO_VECTOR) { 410 iowrite16(msix_vec, vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR); 411 msix_vec = ioread16(vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR); 412 if (msix_vec == VIRTIO_MSI_NO_VECTOR) { 413 err = -EBUSY; 414 goto out_assign; 415 } 416 } 417 418 spin_lock_irqsave(&vp_dev->lock, flags); 419 list_add(&info->node, &vp_dev->virtqueues); 420 spin_unlock_irqrestore(&vp_dev->lock, flags); 421 422 return vq; 423 424out_assign: 425 vring_del_virtqueue(vq); 426out_activate_queue: 427 iowrite32(0, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN); 428 free_pages_exact(info->queue, size); 429out_info: 430 kfree(info); 431 return ERR_PTR(err); 432} 433 434static void vp_del_vq(struct virtqueue *vq) 435{ 436 struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev); 437 struct virtio_pci_vq_info *info = vq->priv; 438 unsigned long flags, size; 439 440 spin_lock_irqsave(&vp_dev->lock, flags); 441 list_del(&info->node); 442 spin_unlock_irqrestore(&vp_dev->lock, flags); 443 444 iowrite16(info->queue_index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_SEL); 445 446 if (vp_dev->msix_enabled) { 447 iowrite16(VIRTIO_MSI_NO_VECTOR, 448 vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR); 449 /* Flush the write out to device */ 450 ioread8(vp_dev->ioaddr + VIRTIO_PCI_ISR); 451 } 452 453 vring_del_virtqueue(vq); 454 455 /* Select and deactivate the queue */ 456 iowrite32(0, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN); 457 458 size = PAGE_ALIGN(vring_size(info->num, VIRTIO_PCI_VRING_ALIGN)); 459 free_pages_exact(info->queue, size); 460 kfree(info); 461} 462 463/* the config->del_vqs() implementation */ 464static void vp_del_vqs(struct virtio_device *vdev) 465{ 466 struct virtio_pci_device *vp_dev = to_vp_device(vdev); 467 struct virtqueue *vq, *n; 468 struct virtio_pci_vq_info *info; 469 470 list_for_each_entry_safe(vq, n, &vdev->vqs, list) { 471 info = vq->priv; 472 if (vp_dev->per_vq_vectors && 473 info->msix_vector != VIRTIO_MSI_NO_VECTOR) 474 free_irq(vp_dev->msix_entries[info->msix_vector].vector, 475 vq); 476 vp_del_vq(vq); 477 } 478 vp_dev->per_vq_vectors = false; 479 480 vp_free_vectors(vdev); 481} 482 483static int vp_try_to_find_vqs(struct virtio_device *vdev, unsigned nvqs, 484 struct virtqueue *vqs[], 485 vq_callback_t *callbacks[], 486 const char *names[], 487 bool use_msix, 488 bool per_vq_vectors) 489{ 490 struct virtio_pci_device *vp_dev = to_vp_device(vdev); 491 u16 msix_vec; 492 int i, err, nvectors, allocated_vectors; 493 494 if (!use_msix) { 495 /* Old style: one normal interrupt for change and all vqs. */ 496 err = vp_request_intx(vdev); 497 if (err) 498 goto error_request; 499 } else { 500 if (per_vq_vectors) { 501 /* Best option: one for change interrupt, one per vq. */ 502 nvectors = 1; 503 for (i = 0; i < nvqs; ++i) 504 if (callbacks[i]) 505 ++nvectors; 506 } else { 507 /* Second best: one for change, shared for all vqs. */ 508 nvectors = 2; 509 } 510 511 err = vp_request_msix_vectors(vdev, nvectors, per_vq_vectors); 512 if (err) 513 goto error_request; 514 } 515 516 vp_dev->per_vq_vectors = per_vq_vectors; 517 allocated_vectors = vp_dev->msix_used_vectors; 518 for (i = 0; i < nvqs; ++i) { 519 if (!callbacks[i] || !vp_dev->msix_enabled) 520 msix_vec = VIRTIO_MSI_NO_VECTOR; 521 else if (vp_dev->per_vq_vectors) 522 msix_vec = allocated_vectors++; 523 else 524 msix_vec = VP_MSIX_VQ_VECTOR; 525 vqs[i] = setup_vq(vdev, i, callbacks[i], names[i], msix_vec); 526 if (IS_ERR(vqs[i])) { 527 err = PTR_ERR(vqs[i]); 528 goto error_find; 529 } 530 531 if (!vp_dev->per_vq_vectors || msix_vec == VIRTIO_MSI_NO_VECTOR) 532 continue; 533 534 /* allocate per-vq irq if available and necessary */ 535 snprintf(vp_dev->msix_names[msix_vec], 536 sizeof *vp_dev->msix_names, 537 "%s-%s", 538 dev_name(&vp_dev->vdev.dev), names[i]); 539 err = request_irq(vp_dev->msix_entries[msix_vec].vector, 540 vring_interrupt, 0, 541 vp_dev->msix_names[msix_vec], 542 vqs[i]); 543 if (err) { 544 vp_del_vq(vqs[i]); 545 goto error_find; 546 } 547 } 548 return 0; 549 550error_find: 551 vp_del_vqs(vdev); 552 553error_request: 554 return err; 555} 556 557/* the config->find_vqs() implementation */ 558static int vp_find_vqs(struct virtio_device *vdev, unsigned nvqs, 559 struct virtqueue *vqs[], 560 vq_callback_t *callbacks[], 561 const char *names[]) 562{ 563 int err; 564 565 /* Try MSI-X with one vector per queue. */ 566 err = vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names, true, true); 567 if (!err) 568 return 0; 569 /* Fallback: MSI-X with one vector for config, one shared for queues. */ 570 err = vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names, 571 true, false); 572 if (!err) 573 return 0; 574 /* Finally fall back to regular interrupts. */ 575 return vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names, 576 false, false); 577} 578 579static struct virtio_config_ops virtio_pci_config_ops = { 580 .get = vp_get, 581 .set = vp_set, 582 .get_status = vp_get_status, 583 .set_status = vp_set_status, 584 .reset = vp_reset, 585 .find_vqs = vp_find_vqs, 586 .del_vqs = vp_del_vqs, 587 .get_features = vp_get_features, 588 .finalize_features = vp_finalize_features, 589}; 590 591static void virtio_pci_release_dev(struct device *_d) 592{ 593 struct virtio_device *dev = container_of(_d, struct virtio_device, dev); 594 struct virtio_pci_device *vp_dev = to_vp_device(dev); 595 struct pci_dev *pci_dev = vp_dev->pci_dev; 596 597 vp_del_vqs(dev); 598 pci_set_drvdata(pci_dev, NULL); 599 pci_iounmap(pci_dev, vp_dev->ioaddr); 600 pci_release_regions(pci_dev); 601 pci_disable_device(pci_dev); 602 kfree(vp_dev); 603} 604 605/* the PCI probing function */ 606static int __devinit virtio_pci_probe(struct pci_dev *pci_dev, 607 const struct pci_device_id *id) 608{ 609 struct virtio_pci_device *vp_dev; 610 int err; 611 612 /* We only own devices >= 0x1000 and <= 0x103f: leave the rest. */ 613 if (pci_dev->device < 0x1000 || pci_dev->device > 0x103f) 614 return -ENODEV; 615 616 if (pci_dev->revision != VIRTIO_PCI_ABI_VERSION) { 617 printk(KERN_ERR "virtio_pci: expected ABI version %d, got %d\n", 618 VIRTIO_PCI_ABI_VERSION, pci_dev->revision); 619 return -ENODEV; 620 } 621 622 /* allocate our structure and fill it out */ 623 vp_dev = kzalloc(sizeof(struct virtio_pci_device), GFP_KERNEL); 624 if (vp_dev == NULL) 625 return -ENOMEM; 626 627 vp_dev->vdev.dev.parent = &pci_dev->dev; 628 vp_dev->vdev.dev.release = virtio_pci_release_dev; 629 vp_dev->vdev.config = &virtio_pci_config_ops; 630 vp_dev->pci_dev = pci_dev; 631 INIT_LIST_HEAD(&vp_dev->virtqueues); 632 spin_lock_init(&vp_dev->lock); 633 634 /* Disable MSI/MSIX to bring device to a known good state. */ 635 pci_msi_off(pci_dev); 636 637 /* enable the device */ 638 err = pci_enable_device(pci_dev); 639 if (err) 640 goto out; 641 642 err = pci_request_regions(pci_dev, "virtio-pci"); 643 if (err) 644 goto out_enable_device; 645 646 vp_dev->ioaddr = pci_iomap(pci_dev, 0, 0); 647 if (vp_dev->ioaddr == NULL) 648 goto out_req_regions; 649 650 pci_set_drvdata(pci_dev, vp_dev); 651 pci_set_master(pci_dev); 652 653 /* we use the subsystem vendor/device id as the virtio vendor/device 654 * id. this allows us to use the same PCI vendor/device id for all 655 * virtio devices and to identify the particular virtio driver by 656 * the subsystem ids */ 657 vp_dev->vdev.id.vendor = pci_dev->subsystem_vendor; 658 vp_dev->vdev.id.device = pci_dev->subsystem_device; 659 660 /* finally register the virtio device */ 661 err = register_virtio_device(&vp_dev->vdev); 662 if (err) 663 goto out_set_drvdata; 664 665 return 0; 666 667out_set_drvdata: 668 pci_set_drvdata(pci_dev, NULL); 669 pci_iounmap(pci_dev, vp_dev->ioaddr); 670out_req_regions: 671 pci_release_regions(pci_dev); 672out_enable_device: 673 pci_disable_device(pci_dev); 674out: 675 kfree(vp_dev); 676 return err; 677} 678 679static void __devexit virtio_pci_remove(struct pci_dev *pci_dev) 680{ 681 struct virtio_pci_device *vp_dev = pci_get_drvdata(pci_dev); 682 683 unregister_virtio_device(&vp_dev->vdev); 684} 685 686#ifdef CONFIG_PM 687static int virtio_pci_suspend(struct pci_dev *pci_dev, pm_message_t state) 688{ 689 pci_save_state(pci_dev); 690 pci_set_power_state(pci_dev, PCI_D3hot); 691 return 0; 692} 693 694static int virtio_pci_resume(struct pci_dev *pci_dev) 695{ 696 pci_restore_state(pci_dev); 697 pci_set_power_state(pci_dev, PCI_D0); 698 return 0; 699} 700#endif 701 702static struct pci_driver virtio_pci_driver = { 703 .name = "virtio-pci", 704 .id_table = virtio_pci_id_table, 705 .probe = virtio_pci_probe, 706 .remove = __devexit_p(virtio_pci_remove), 707#ifdef CONFIG_PM 708 .suspend = virtio_pci_suspend, 709 .resume = virtio_pci_resume, 710#endif 711}; 712 713static int __init virtio_pci_init(void) 714{ 715 return pci_register_driver(&virtio_pci_driver); 716} 717 718module_init(virtio_pci_init); 719 720static void __exit virtio_pci_exit(void) 721{ 722 pci_unregister_driver(&virtio_pci_driver); 723} 724 725module_exit(virtio_pci_exit); 726