Commit | Line | Data |
---|---|---|
48bae050 EB |
1 | /* |
2 | * linux/drivers/misc/xillybus_pcie.c | |
3 | * | |
4 | * Copyright 2011 Xillybus Ltd, http://xillybus.com | |
5 | * | |
6 | * Driver for the Xillybus FPGA/host framework using PCI Express. | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the smems of the GNU General Public License as published by | |
10 | * the Free Software Foundation; version 2 of the License. | |
11 | */ | |
12 | ||
13 | #include <linux/module.h> | |
14 | #include <linux/pci.h> | |
15 | #include <linux/pci-aspm.h> | |
16 | #include <linux/slab.h> | |
17 | #include "xillybus.h" | |
18 | ||
19 | MODULE_DESCRIPTION("Xillybus driver for PCIe"); | |
20 | MODULE_AUTHOR("Eli Billauer, Xillybus Ltd."); | |
21 | MODULE_VERSION("1.06"); | |
22 | MODULE_ALIAS("xillybus_pcie"); | |
23 | MODULE_LICENSE("GPL v2"); | |
24 | ||
25 | #define PCI_DEVICE_ID_XILLYBUS 0xebeb | |
26 | ||
27 | #define PCI_VENDOR_ID_ALTERA 0x1172 | |
28 | #define PCI_VENDOR_ID_ACTEL 0x11aa | |
29 | #define PCI_VENDOR_ID_LATTICE 0x1204 | |
30 | ||
e71042f2 EB |
31 | static const char xillyname[] = "xillybus_pcie"; |
32 | ||
41e043fc | 33 | static const struct pci_device_id xillyids[] = { |
48bae050 EB |
34 | {PCI_DEVICE(PCI_VENDOR_ID_XILINX, PCI_DEVICE_ID_XILLYBUS)}, |
35 | {PCI_DEVICE(PCI_VENDOR_ID_ALTERA, PCI_DEVICE_ID_XILLYBUS)}, | |
36 | {PCI_DEVICE(PCI_VENDOR_ID_ACTEL, PCI_DEVICE_ID_XILLYBUS)}, | |
37 | {PCI_DEVICE(PCI_VENDOR_ID_LATTICE, PCI_DEVICE_ID_XILLYBUS)}, | |
38 | { /* End: all zeroes */ } | |
39 | }; | |
40 | ||
41 | static int xilly_pci_direction(int direction) | |
42 | { | |
43 | switch (direction) { | |
44 | case DMA_TO_DEVICE: | |
45 | return PCI_DMA_TODEVICE; | |
46 | case DMA_FROM_DEVICE: | |
47 | return PCI_DMA_FROMDEVICE; | |
48 | default: | |
49 | return PCI_DMA_BIDIRECTIONAL; | |
50 | } | |
51 | } | |
52 | ||
53 | static void xilly_dma_sync_single_for_cpu_pci(struct xilly_endpoint *ep, | |
54 | dma_addr_t dma_handle, | |
55 | size_t size, | |
56 | int direction) | |
57 | { | |
58 | pci_dma_sync_single_for_cpu(ep->pdev, | |
59 | dma_handle, | |
60 | size, | |
61 | xilly_pci_direction(direction)); | |
62 | } | |
63 | ||
64 | static void xilly_dma_sync_single_for_device_pci(struct xilly_endpoint *ep, | |
65 | dma_addr_t dma_handle, | |
66 | size_t size, | |
67 | int direction) | |
68 | { | |
69 | pci_dma_sync_single_for_device(ep->pdev, | |
70 | dma_handle, | |
71 | size, | |
72 | xilly_pci_direction(direction)); | |
73 | } | |
74 | ||
525be905 EB |
75 | static void xilly_pci_unmap(void *ptr) |
76 | { | |
77 | struct xilly_mapping *data = ptr; | |
78 | ||
79 | pci_unmap_single(data->device, data->dma_addr, | |
80 | data->size, data->direction); | |
81 | ||
82 | kfree(ptr); | |
83 | } | |
84 | ||
48bae050 EB |
85 | /* |
86 | * Map either through the PCI DMA mapper or the non_PCI one. Behind the | |
87 | * scenes exactly the same functions are called with the same parameters, | |
88 | * but that can change. | |
89 | */ | |
90 | ||
525be905 EB |
91 | static int xilly_map_single_pci(struct xilly_endpoint *ep, |
92 | void *ptr, | |
93 | size_t size, | |
94 | int direction, | |
95 | dma_addr_t *ret_dma_handle | |
48bae050 EB |
96 | ) |
97 | { | |
48bae050 | 98 | int pci_direction; |
525be905 EB |
99 | dma_addr_t addr; |
100 | struct xilly_mapping *this; | |
40931bbb | 101 | int rc; |
48bae050 | 102 | |
525be905 | 103 | this = kzalloc(sizeof(*this), GFP_KERNEL); |
48bae050 | 104 | if (!this) |
525be905 | 105 | return -ENOMEM; |
48bae050 EB |
106 | |
107 | pci_direction = xilly_pci_direction(direction); | |
525be905 | 108 | |
48bae050 | 109 | addr = pci_map_single(ep->pdev, ptr, size, pci_direction); |
48bae050 EB |
110 | |
111 | if (pci_dma_mapping_error(ep->pdev, addr)) { | |
112 | kfree(this); | |
525be905 | 113 | return -ENODEV; |
48bae050 EB |
114 | } |
115 | ||
525be905 | 116 | this->device = ep->pdev; |
48bae050 | 117 | this->dma_addr = addr; |
48bae050 | 118 | this->size = size; |
525be905 | 119 | this->direction = pci_direction; |
48bae050 | 120 | |
525be905 | 121 | *ret_dma_handle = addr; |
48bae050 | 122 | |
525be905 | 123 | rc = devm_add_action(ep->dev, xilly_pci_unmap, this); |
525be905 EB |
124 | if (rc) { |
125 | pci_unmap_single(ep->pdev, addr, size, pci_direction); | |
126 | kfree(this); | |
40931bbb | 127 | return rc; |
525be905 EB |
128 | } |
129 | ||
40931bbb | 130 | return 0; |
48bae050 EB |
131 | } |
132 | ||
133 | static struct xilly_endpoint_hardware pci_hw = { | |
134 | .owner = THIS_MODULE, | |
7ee9ded2 EB |
135 | .hw_sync_sgl_for_cpu = xilly_dma_sync_single_for_cpu_pci, |
136 | .hw_sync_sgl_for_device = xilly_dma_sync_single_for_device_pci, | |
48bae050 | 137 | .map_single = xilly_map_single_pci, |
48bae050 EB |
138 | }; |
139 | ||
140 | static int xilly_probe(struct pci_dev *pdev, | |
91a2dea8 | 141 | const struct pci_device_id *ent) |
48bae050 EB |
142 | { |
143 | struct xilly_endpoint *endpoint; | |
40931bbb | 144 | int rc; |
48bae050 | 145 | |
26a6fc93 | 146 | endpoint = xillybus_init_endpoint(pdev, &pdev->dev, &pci_hw); |
48bae050 EB |
147 | |
148 | if (!endpoint) | |
149 | return -ENOMEM; | |
150 | ||
151 | pci_set_drvdata(pdev, endpoint); | |
152 | ||
9267462e | 153 | rc = pcim_enable_device(pdev); |
48bae050 | 154 | if (rc) { |
2cb85c08 | 155 | dev_err(endpoint->dev, |
9267462e EB |
156 | "pcim_enable_device() failed. Aborting.\n"); |
157 | return rc; | |
48bae050 EB |
158 | } |
159 | ||
9267462e EB |
160 | /* L0s has caused packet drops. No power saving, thank you. */ |
161 | ||
162 | pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S); | |
163 | ||
48bae050 | 164 | if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) { |
2cb85c08 EB |
165 | dev_err(endpoint->dev, |
166 | "Incorrect BAR configuration. Aborting.\n"); | |
9267462e | 167 | return -ENODEV; |
48bae050 EB |
168 | } |
169 | ||
9267462e | 170 | rc = pcim_iomap_regions(pdev, 0x01, xillyname); |
48bae050 | 171 | if (rc) { |
2cb85c08 | 172 | dev_err(endpoint->dev, |
9267462e EB |
173 | "pcim_iomap_regions() failed. Aborting.\n"); |
174 | return rc; | |
48bae050 EB |
175 | } |
176 | ||
9267462e | 177 | endpoint->registers = pcim_iomap_table(pdev)[0]; |
48bae050 EB |
178 | |
179 | pci_set_master(pdev); | |
180 | ||
181 | /* Set up a single MSI interrupt */ | |
182 | if (pci_enable_msi(pdev)) { | |
2cb85c08 EB |
183 | dev_err(endpoint->dev, |
184 | "Failed to enable MSI interrupts. Aborting.\n"); | |
9267462e | 185 | return -ENODEV; |
48bae050 | 186 | } |
9267462e EB |
187 | rc = devm_request_irq(&pdev->dev, pdev->irq, xillybus_isr, 0, |
188 | xillyname, endpoint); | |
48bae050 | 189 | if (rc) { |
2cb85c08 EB |
190 | dev_err(endpoint->dev, |
191 | "Failed to register MSI handler. Aborting.\n"); | |
9267462e | 192 | return -ENODEV; |
48bae050 EB |
193 | } |
194 | ||
195 | /* | |
6497a875 EB |
196 | * Some (old and buggy?) hardware drops 64-bit addressed PCIe packets, |
197 | * even when the PCIe driver claims that a 64-bit mask is OK. On the | |
198 | * other hand, on some architectures, 64-bit addressing is mandatory. | |
199 | * So go for the 64-bit mask only when failing is the other option. | |
48bae050 EB |
200 | */ |
201 | ||
c14cc622 | 202 | if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) { |
48bae050 | 203 | endpoint->dma_using_dac = 0; |
6497a875 EB |
204 | } else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) { |
205 | endpoint->dma_using_dac = 1; | |
c14cc622 | 206 | } else { |
2cb85c08 | 207 | dev_err(endpoint->dev, "Failed to set DMA mask. Aborting.\n"); |
9267462e | 208 | return -ENODEV; |
48bae050 EB |
209 | } |
210 | ||
525be905 | 211 | return xillybus_endpoint_discovery(endpoint); |
48bae050 EB |
212 | } |
213 | ||
214 | static void xilly_remove(struct pci_dev *pdev) | |
215 | { | |
216 | struct xilly_endpoint *endpoint = pci_get_drvdata(pdev); | |
217 | ||
218 | xillybus_endpoint_remove(endpoint); | |
48bae050 EB |
219 | } |
220 | ||
221 | MODULE_DEVICE_TABLE(pci, xillyids); | |
222 | ||
223 | static struct pci_driver xillybus_driver = { | |
224 | .name = xillyname, | |
225 | .id_table = xillyids, | |
226 | .probe = xilly_probe, | |
227 | .remove = xilly_remove, | |
228 | }; | |
229 | ||
230 | module_pci_driver(xillybus_driver); |