virtio_pci.c 13 KB

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