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