dw-edma-pcie.c 6.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (c) 2018-2019 Synopsys, Inc. and/or its affiliates.
  4. * Synopsys DesignWare eDMA PCIe driver
  5. *
  6. * Author: Gustavo Pimentel <gustavo.pimentel@synopsys.com>
  7. */
  8. #include <linux/kernel.h>
  9. #include <linux/module.h>
  10. #include <linux/pci.h>
  11. #include <linux/device.h>
  12. #include <linux/dma/edma.h>
  13. #include <linux/pci-epf.h>
  14. #include <linux/msi.h>
  15. #include "dw-edma-core.h"
  16. struct dw_edma_pcie_data {
  17. /* eDMA registers location */
  18. enum pci_barno rg_bar;
  19. off_t rg_off;
  20. size_t rg_sz;
  21. /* eDMA memory linked list location */
  22. enum pci_barno ll_bar;
  23. off_t ll_off;
  24. size_t ll_sz;
  25. /* eDMA memory data location */
  26. enum pci_barno dt_bar;
  27. off_t dt_off;
  28. size_t dt_sz;
  29. /* Other */
  30. u32 version;
  31. enum dw_edma_mode mode;
  32. u8 irqs;
  33. };
  34. static const struct dw_edma_pcie_data snps_edda_data = {
  35. /* eDMA registers location */
  36. .rg_bar = BAR_0,
  37. .rg_off = 0x00001000, /* 4 Kbytes */
  38. .rg_sz = 0x00002000, /* 8 Kbytes */
  39. /* eDMA memory linked list location */
  40. .ll_bar = BAR_2,
  41. .ll_off = 0x00000000, /* 0 Kbytes */
  42. .ll_sz = 0x00800000, /* 8 Mbytes */
  43. /* eDMA memory data location */
  44. .dt_bar = BAR_2,
  45. .dt_off = 0x00800000, /* 8 Mbytes */
  46. .dt_sz = 0x03800000, /* 56 Mbytes */
  47. /* Other */
  48. .version = 0,
  49. .mode = EDMA_MODE_UNROLL,
  50. .irqs = 1,
  51. };
  52. static int dw_edma_pcie_irq_vector(struct device *dev, unsigned int nr)
  53. {
  54. return pci_irq_vector(to_pci_dev(dev), nr);
  55. }
  56. static const struct dw_edma_core_ops dw_edma_pcie_core_ops = {
  57. .irq_vector = dw_edma_pcie_irq_vector,
  58. };
  59. static int dw_edma_pcie_probe(struct pci_dev *pdev,
  60. const struct pci_device_id *pid)
  61. {
  62. const struct dw_edma_pcie_data *pdata = (void *)pid->driver_data;
  63. struct device *dev = &pdev->dev;
  64. struct dw_edma_chip *chip;
  65. int err, nr_irqs;
  66. struct dw_edma *dw;
  67. /* Enable PCI device */
  68. err = pcim_enable_device(pdev);
  69. if (err) {
  70. pci_err(pdev, "enabling device failed\n");
  71. return err;
  72. }
  73. /* Mapping PCI BAR regions */
  74. err = pcim_iomap_regions(pdev, BIT(pdata->rg_bar) |
  75. BIT(pdata->ll_bar) |
  76. BIT(pdata->dt_bar),
  77. pci_name(pdev));
  78. if (err) {
  79. pci_err(pdev, "eDMA BAR I/O remapping failed\n");
  80. return err;
  81. }
  82. pci_set_master(pdev);
  83. /* DMA configuration */
  84. err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
  85. if (!err) {
  86. err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
  87. if (err) {
  88. pci_err(pdev, "consistent DMA mask 64 set failed\n");
  89. return err;
  90. }
  91. } else {
  92. pci_err(pdev, "DMA mask 64 set failed\n");
  93. err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
  94. if (err) {
  95. pci_err(pdev, "DMA mask 32 set failed\n");
  96. return err;
  97. }
  98. err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
  99. if (err) {
  100. pci_err(pdev, "consistent DMA mask 32 set failed\n");
  101. return err;
  102. }
  103. }
  104. /* Data structure allocation */
  105. chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
  106. if (!chip)
  107. return -ENOMEM;
  108. dw = devm_kzalloc(dev, sizeof(*dw), GFP_KERNEL);
  109. if (!dw)
  110. return -ENOMEM;
  111. /* IRQs allocation */
  112. nr_irqs = pci_alloc_irq_vectors(pdev, 1, pdata->irqs,
  113. PCI_IRQ_MSI | PCI_IRQ_MSIX);
  114. if (nr_irqs < 1) {
  115. pci_err(pdev, "fail to alloc IRQ vector (number of IRQs=%u)\n",
  116. nr_irqs);
  117. return -EPERM;
  118. }
  119. /* Data structure initialization */
  120. chip->dw = dw;
  121. chip->dev = dev;
  122. chip->id = pdev->devfn;
  123. chip->irq = pdev->irq;
  124. dw->rg_region.vaddr = pcim_iomap_table(pdev)[pdata->rg_bar];
  125. dw->rg_region.vaddr += pdata->rg_off;
  126. dw->rg_region.paddr = pdev->resource[pdata->rg_bar].start;
  127. dw->rg_region.paddr += pdata->rg_off;
  128. dw->rg_region.sz = pdata->rg_sz;
  129. dw->ll_region.vaddr = pcim_iomap_table(pdev)[pdata->ll_bar];
  130. dw->ll_region.vaddr += pdata->ll_off;
  131. dw->ll_region.paddr = pdev->resource[pdata->ll_bar].start;
  132. dw->ll_region.paddr += pdata->ll_off;
  133. dw->ll_region.sz = pdata->ll_sz;
  134. dw->dt_region.vaddr = pcim_iomap_table(pdev)[pdata->dt_bar];
  135. dw->dt_region.vaddr += pdata->dt_off;
  136. dw->dt_region.paddr = pdev->resource[pdata->dt_bar].start;
  137. dw->dt_region.paddr += pdata->dt_off;
  138. dw->dt_region.sz = pdata->dt_sz;
  139. dw->version = pdata->version;
  140. dw->mode = pdata->mode;
  141. dw->nr_irqs = nr_irqs;
  142. dw->ops = &dw_edma_pcie_core_ops;
  143. /* Debug info */
  144. pci_dbg(pdev, "Version:\t%u\n", dw->version);
  145. pci_dbg(pdev, "Mode:\t%s\n",
  146. dw->mode == EDMA_MODE_LEGACY ? "Legacy" : "Unroll");
  147. pci_dbg(pdev, "Registers:\tBAR=%u, off=0x%.8lx, sz=0x%zx bytes, addr(v=%p, p=%pa)\n",
  148. pdata->rg_bar, pdata->rg_off, pdata->rg_sz,
  149. dw->rg_region.vaddr, &dw->rg_region.paddr);
  150. pci_dbg(pdev, "L. List:\tBAR=%u, off=0x%.8lx, sz=0x%zx bytes, addr(v=%p, p=%pa)\n",
  151. pdata->ll_bar, pdata->ll_off, pdata->ll_sz,
  152. dw->ll_region.vaddr, &dw->ll_region.paddr);
  153. pci_dbg(pdev, "Data:\tBAR=%u, off=0x%.8lx, sz=0x%zx bytes, addr(v=%p, p=%pa)\n",
  154. pdata->dt_bar, pdata->dt_off, pdata->dt_sz,
  155. dw->dt_region.vaddr, &dw->dt_region.paddr);
  156. pci_dbg(pdev, "Nr. IRQs:\t%u\n", dw->nr_irqs);
  157. /* Validating if PCI interrupts were enabled */
  158. if (!pci_dev_msi_enabled(pdev)) {
  159. pci_err(pdev, "enable interrupt failed\n");
  160. return -EPERM;
  161. }
  162. dw->irq = devm_kcalloc(dev, nr_irqs, sizeof(*dw->irq), GFP_KERNEL);
  163. if (!dw->irq)
  164. return -ENOMEM;
  165. /* Starting eDMA driver */
  166. err = dw_edma_probe(chip);
  167. if (err) {
  168. pci_err(pdev, "eDMA probe failed\n");
  169. return err;
  170. }
  171. /* Saving data structure reference */
  172. pci_set_drvdata(pdev, chip);
  173. return 0;
  174. }
  175. static void dw_edma_pcie_remove(struct pci_dev *pdev)
  176. {
  177. struct dw_edma_chip *chip = pci_get_drvdata(pdev);
  178. int err;
  179. /* Stopping eDMA driver */
  180. err = dw_edma_remove(chip);
  181. if (err)
  182. pci_warn(pdev, "can't remove device properly: %d\n", err);
  183. /* Freeing IRQs */
  184. pci_free_irq_vectors(pdev);
  185. }
  186. static const struct pci_device_id dw_edma_pcie_id_table[] = {
  187. { PCI_DEVICE_DATA(SYNOPSYS, EDDA, &snps_edda_data) },
  188. { }
  189. };
  190. MODULE_DEVICE_TABLE(pci, dw_edma_pcie_id_table);
  191. static struct pci_driver dw_edma_pcie_driver = {
  192. .name = "dw-edma-pcie",
  193. .id_table = dw_edma_pcie_id_table,
  194. .probe = dw_edma_pcie_probe,
  195. .remove = dw_edma_pcie_remove,
  196. };
  197. module_pci_driver(dw_edma_pcie_driver);
  198. MODULE_LICENSE("GPL v2");
  199. MODULE_DESCRIPTION("Synopsys DesignWare eDMA PCIe driver");
  200. MODULE_AUTHOR("Gustavo Pimentel <gustavo.pimentel@synopsys.com>");