Commit | Line | Data |
---|---|---|
83125a3a AR |
1 | /* |
2 | * arch/x86/pci/sta2x11-fixup.c | |
3 | * glue code for lib/swiotlb.c and DMA translation between STA2x11 | |
4 | * AMBA memory mapping and the X86 memory mapping | |
5 | * | |
6 | * ST Microelectronics ConneXt (STA2X11/STA2X10) | |
7 | * | |
8 | * Copyright (c) 2010-2011 Wind River Systems, Inc. | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or modify | |
11 | * it under the terms of the GNU General Public License version 2 as | |
12 | * published by the Free Software Foundation. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
17 | * See the GNU General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License | |
20 | * along with this program; if not, write to the Free Software | |
21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
22 | * | |
23 | */ | |
24 | ||
25 | #include <linux/pci.h> | |
26 | #include <linux/pci_ids.h> | |
27 | #include <linux/export.h> | |
28 | #include <linux/list.h> | |
29 | ||
30 | #define STA2X11_SWIOTLB_SIZE (4*1024*1024) | |
31 | extern int swiotlb_late_init_with_default_size(size_t default_size); | |
32 | ||
33 | /* | |
34 | * We build a list of bus numbers that are under the ConneXt. The | |
35 | * main bridge hosts 4 busses, which are the 4 endpoints, in order. | |
36 | */ | |
37 | #define STA2X11_NR_EP 4 /* 0..3 included */ | |
38 | #define STA2X11_NR_FUNCS 8 /* 0..7 included */ | |
39 | #define STA2X11_AMBA_SIZE (512 << 20) | |
40 | ||
41 | struct sta2x11_ahb_regs { /* saved during suspend */ | |
42 | u32 base, pexlbase, pexhbase, crw; | |
43 | }; | |
44 | ||
45 | struct sta2x11_mapping { | |
46 | u32 amba_base; | |
47 | int is_suspended; | |
48 | struct sta2x11_ahb_regs regs[STA2X11_NR_FUNCS]; | |
49 | }; | |
50 | ||
51 | struct sta2x11_instance { | |
52 | struct list_head list; | |
53 | int bus0; | |
54 | struct sta2x11_mapping map[STA2X11_NR_EP]; | |
55 | }; | |
56 | ||
57 | static LIST_HEAD(sta2x11_instance_list); | |
58 | ||
59 | /* At probe time, record new instances of this bridge (likely one only) */ | |
60 | static void sta2x11_new_instance(struct pci_dev *pdev) | |
61 | { | |
62 | struct sta2x11_instance *instance; | |
63 | ||
64 | instance = kzalloc(sizeof(*instance), GFP_ATOMIC); | |
65 | if (!instance) | |
66 | return; | |
67 | /* This has a subordinate bridge, with 4 more-subordinate ones */ | |
68 | instance->bus0 = pdev->subordinate->number + 1; | |
69 | ||
70 | if (list_empty(&sta2x11_instance_list)) { | |
71 | int size = STA2X11_SWIOTLB_SIZE; | |
72 | /* First instance: register your own swiotlb area */ | |
73 | dev_info(&pdev->dev, "Using SWIOTLB (size %i)\n", size); | |
74 | if (swiotlb_late_init_with_default_size(size)) | |
75 | dev_emerg(&pdev->dev, "init swiotlb failed\n"); | |
76 | } | |
77 | list_add(&instance->list, &sta2x11_instance_list); | |
78 | } | |
79 | DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_STMICRO, 0xcc17, sta2x11_new_instance); | |
80 | ||
81 | /* | |
82 | * Utility functions used in this file from below | |
83 | */ | |
84 | static struct sta2x11_instance *sta2x11_pdev_to_instance(struct pci_dev *pdev) | |
85 | { | |
86 | struct sta2x11_instance *instance; | |
87 | int ep; | |
88 | ||
89 | list_for_each_entry(instance, &sta2x11_instance_list, list) { | |
90 | ep = pdev->bus->number - instance->bus0; | |
91 | if (ep >= 0 && ep < STA2X11_NR_EP) | |
92 | return instance; | |
93 | } | |
94 | return NULL; | |
95 | } | |
96 | ||
97 | static int sta2x11_pdev_to_ep(struct pci_dev *pdev) | |
98 | { | |
99 | struct sta2x11_instance *instance; | |
100 | ||
101 | instance = sta2x11_pdev_to_instance(pdev); | |
102 | if (!instance) | |
103 | return -1; | |
104 | ||
105 | return pdev->bus->number - instance->bus0; | |
106 | } | |
107 | ||
108 | static struct sta2x11_mapping *sta2x11_pdev_to_mapping(struct pci_dev *pdev) | |
109 | { | |
110 | struct sta2x11_instance *instance; | |
111 | int ep; | |
112 | ||
113 | instance = sta2x11_pdev_to_instance(pdev); | |
114 | if (!instance) | |
115 | return NULL; | |
116 | ep = sta2x11_pdev_to_ep(pdev); | |
117 | return instance->map + ep; | |
118 | } | |
119 | ||
120 | /* This is exported, as some devices need to access the MFD registers */ | |
121 | struct sta2x11_instance *sta2x11_get_instance(struct pci_dev *pdev) | |
122 | { | |
123 | return sta2x11_pdev_to_instance(pdev); | |
124 | } | |
125 | EXPORT_SYMBOL(sta2x11_get_instance); | |
126 | ||
127 | ||
128 | /** | |
129 | * p2a - Translate physical address to STA2x11 AMBA address, | |
130 | * used for DMA transfers to STA2x11 | |
131 | * @p: Physical address | |
132 | * @pdev: PCI device (must be hosted within the connext) | |
133 | */ | |
134 | static dma_addr_t p2a(dma_addr_t p, struct pci_dev *pdev) | |
135 | { | |
136 | struct sta2x11_mapping *map; | |
137 | dma_addr_t a; | |
138 | ||
139 | map = sta2x11_pdev_to_mapping(pdev); | |
140 | a = p + map->amba_base; | |
141 | return a; | |
142 | } | |
143 | ||
144 | /** | |
145 | * a2p - Translate STA2x11 AMBA address to physical address | |
146 | * used for DMA transfers from STA2x11 | |
147 | * @a: STA2x11 AMBA address | |
148 | * @pdev: PCI device (must be hosted within the connext) | |
149 | */ | |
150 | static dma_addr_t a2p(dma_addr_t a, struct pci_dev *pdev) | |
151 | { | |
152 | struct sta2x11_mapping *map; | |
153 | dma_addr_t p; | |
154 | ||
155 | map = sta2x11_pdev_to_mapping(pdev); | |
156 | p = a - map->amba_base; | |
157 | return p; | |
158 | } | |
159 | ||
160 | /** | |
161 | * sta2x11_swiotlb_alloc_coherent - Allocate swiotlb bounce buffers | |
162 | * returns virtual address. This is the only "special" function here. | |
163 | * @dev: PCI device | |
164 | * @size: Size of the buffer | |
165 | * @dma_handle: DMA address | |
166 | * @flags: memory flags | |
167 | */ | |
168 | static void *sta2x11_swiotlb_alloc_coherent(struct device *dev, | |
169 | size_t size, | |
170 | dma_addr_t *dma_handle, | |
171 | gfp_t flags, | |
172 | struct dma_attrs *attrs) | |
173 | { | |
174 | void *vaddr; | |
175 | ||
9c5a3621 | 176 | vaddr = x86_swiotlb_alloc_coherent(dev, size, dma_handle, flags, attrs); |
83125a3a AR |
177 | *dma_handle = p2a(*dma_handle, to_pci_dev(dev)); |
178 | return vaddr; | |
179 | } | |
180 | ||
181 | /* We have our own dma_ops: the same as swiotlb but from alloc (above) */ | |
182 | static struct dma_map_ops sta2x11_dma_ops = { | |
183 | .alloc = sta2x11_swiotlb_alloc_coherent, | |
9c5a3621 | 184 | .free = x86_swiotlb_free_coherent, |
83125a3a AR |
185 | .map_page = swiotlb_map_page, |
186 | .unmap_page = swiotlb_unmap_page, | |
187 | .map_sg = swiotlb_map_sg_attrs, | |
188 | .unmap_sg = swiotlb_unmap_sg_attrs, | |
189 | .sync_single_for_cpu = swiotlb_sync_single_for_cpu, | |
190 | .sync_single_for_device = swiotlb_sync_single_for_device, | |
191 | .sync_sg_for_cpu = swiotlb_sync_sg_for_cpu, | |
192 | .sync_sg_for_device = swiotlb_sync_sg_for_device, | |
193 | .mapping_error = swiotlb_dma_mapping_error, | |
194 | .dma_supported = NULL, /* FIXME: we should use this instead! */ | |
195 | }; | |
196 | ||
197 | /* At setup time, we use our own ops if the device is a ConneXt one */ | |
198 | static void sta2x11_setup_pdev(struct pci_dev *pdev) | |
199 | { | |
200 | struct sta2x11_instance *instance = sta2x11_pdev_to_instance(pdev); | |
201 | ||
202 | if (!instance) /* either a sta2x11 bridge or another ST device */ | |
203 | return; | |
204 | pci_set_consistent_dma_mask(pdev, STA2X11_AMBA_SIZE - 1); | |
205 | pci_set_dma_mask(pdev, STA2X11_AMBA_SIZE - 1); | |
206 | pdev->dev.archdata.dma_ops = &sta2x11_dma_ops; | |
207 | ||
208 | /* We must enable all devices as master, for audio DMA to work */ | |
209 | pci_set_master(pdev); | |
210 | } | |
211 | DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_STMICRO, PCI_ANY_ID, sta2x11_setup_pdev); | |
212 | ||
213 | /* | |
214 | * The following three functions are exported (used in swiotlb: FIXME) | |
215 | */ | |
216 | /** | |
217 | * dma_capable - Check if device can manage DMA transfers (FIXME: kill it) | |
218 | * @dev: device for a PCI device | |
219 | * @addr: DMA address | |
220 | * @size: DMA size | |
221 | */ | |
222 | bool dma_capable(struct device *dev, dma_addr_t addr, size_t size) | |
223 | { | |
224 | struct sta2x11_mapping *map; | |
225 | ||
226 | if (dev->archdata.dma_ops != &sta2x11_dma_ops) { | |
227 | if (!dev->dma_mask) | |
228 | return false; | |
229 | return addr + size - 1 <= *dev->dma_mask; | |
230 | } | |
231 | ||
232 | map = sta2x11_pdev_to_mapping(to_pci_dev(dev)); | |
233 | ||
234 | if (!map || (addr < map->amba_base)) | |
235 | return false; | |
236 | if (addr + size >= map->amba_base + STA2X11_AMBA_SIZE) { | |
237 | return false; | |
238 | } | |
239 | ||
240 | return true; | |
241 | } | |
242 | ||
243 | /** | |
244 | * phys_to_dma - Return the DMA AMBA address used for this STA2x11 device | |
245 | * @dev: device for a PCI device | |
246 | * @paddr: Physical address | |
247 | */ | |
248 | dma_addr_t phys_to_dma(struct device *dev, phys_addr_t paddr) | |
249 | { | |
250 | if (dev->archdata.dma_ops != &sta2x11_dma_ops) | |
251 | return paddr; | |
252 | return p2a(paddr, to_pci_dev(dev)); | |
253 | } | |
254 | ||
255 | /** | |
256 | * dma_to_phys - Return the physical address used for this STA2x11 DMA address | |
257 | * @dev: device for a PCI device | |
258 | * @daddr: STA2x11 AMBA DMA address | |
259 | */ | |
260 | phys_addr_t dma_to_phys(struct device *dev, dma_addr_t daddr) | |
261 | { | |
262 | if (dev->archdata.dma_ops != &sta2x11_dma_ops) | |
263 | return daddr; | |
264 | return a2p(daddr, to_pci_dev(dev)); | |
265 | } | |
266 | ||
267 | ||
268 | /* | |
269 | * At boot we must set up the mappings for the pcie-to-amba bridge. | |
270 | * It involves device access, and the same happens at suspend/resume time | |
271 | */ | |
272 | ||
273 | #define AHB_MAPB 0xCA4 | |
274 | #define AHB_CRW(i) (AHB_MAPB + 0 + (i) * 0x10) | |
275 | #define AHB_CRW_SZMASK 0xfffffc00UL | |
276 | #define AHB_CRW_ENABLE (1 << 0) | |
277 | #define AHB_CRW_WTYPE_MEM (2 << 1) | |
278 | #define AHB_CRW_ROE (1UL << 3) /* Relax Order Ena */ | |
279 | #define AHB_CRW_NSE (1UL << 4) /* No Snoop Enable */ | |
280 | #define AHB_BASE(i) (AHB_MAPB + 4 + (i) * 0x10) | |
281 | #define AHB_PEXLBASE(i) (AHB_MAPB + 8 + (i) * 0x10) | |
282 | #define AHB_PEXHBASE(i) (AHB_MAPB + 12 + (i) * 0x10) | |
283 | ||
284 | /* At probe time, enable mapping for each endpoint, using the pdev */ | |
285 | static void sta2x11_map_ep(struct pci_dev *pdev) | |
286 | { | |
287 | struct sta2x11_mapping *map = sta2x11_pdev_to_mapping(pdev); | |
288 | int i; | |
289 | ||
290 | if (!map) | |
291 | return; | |
292 | pci_read_config_dword(pdev, AHB_BASE(0), &map->amba_base); | |
293 | ||
294 | /* Configure AHB mapping */ | |
295 | pci_write_config_dword(pdev, AHB_PEXLBASE(0), 0); | |
296 | pci_write_config_dword(pdev, AHB_PEXHBASE(0), 0); | |
297 | pci_write_config_dword(pdev, AHB_CRW(0), STA2X11_AMBA_SIZE | | |
298 | AHB_CRW_WTYPE_MEM | AHB_CRW_ENABLE); | |
299 | ||
300 | /* Disable all the other windows */ | |
301 | for (i = 1; i < STA2X11_NR_FUNCS; i++) | |
302 | pci_write_config_dword(pdev, AHB_CRW(i), 0); | |
303 | ||
304 | dev_info(&pdev->dev, | |
305 | "sta2x11: Map EP %i: AMBA address %#8x-%#8x\n", | |
306 | sta2x11_pdev_to_ep(pdev), map->amba_base, | |
307 | map->amba_base + STA2X11_AMBA_SIZE - 1); | |
308 | } | |
309 | DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_STMICRO, PCI_ANY_ID, sta2x11_map_ep); | |
310 | ||
311 | #ifdef CONFIG_PM /* Some register values must be saved and restored */ | |
312 | ||
313 | static void suspend_mapping(struct pci_dev *pdev) | |
314 | { | |
315 | struct sta2x11_mapping *map = sta2x11_pdev_to_mapping(pdev); | |
316 | int i; | |
317 | ||
318 | if (!map) | |
319 | return; | |
320 | ||
321 | if (map->is_suspended) | |
322 | return; | |
323 | map->is_suspended = 1; | |
324 | ||
325 | /* Save all window configs */ | |
326 | for (i = 0; i < STA2X11_NR_FUNCS; i++) { | |
327 | struct sta2x11_ahb_regs *regs = map->regs + i; | |
328 | ||
329 | pci_read_config_dword(pdev, AHB_BASE(i), ®s->base); | |
330 | pci_read_config_dword(pdev, AHB_PEXLBASE(i), ®s->pexlbase); | |
331 | pci_read_config_dword(pdev, AHB_PEXHBASE(i), ®s->pexhbase); | |
332 | pci_read_config_dword(pdev, AHB_CRW(i), ®s->crw); | |
333 | } | |
334 | } | |
335 | DECLARE_PCI_FIXUP_SUSPEND(PCI_VENDOR_ID_STMICRO, PCI_ANY_ID, suspend_mapping); | |
336 | ||
337 | static void resume_mapping(struct pci_dev *pdev) | |
338 | { | |
339 | struct sta2x11_mapping *map = sta2x11_pdev_to_mapping(pdev); | |
340 | int i; | |
341 | ||
342 | if (!map) | |
343 | return; | |
344 | ||
345 | ||
346 | if (!map->is_suspended) | |
347 | goto out; | |
348 | map->is_suspended = 0; | |
349 | ||
350 | /* Restore all window configs */ | |
351 | for (i = 0; i < STA2X11_NR_FUNCS; i++) { | |
352 | struct sta2x11_ahb_regs *regs = map->regs + i; | |
353 | ||
354 | pci_write_config_dword(pdev, AHB_BASE(i), regs->base); | |
355 | pci_write_config_dword(pdev, AHB_PEXLBASE(i), regs->pexlbase); | |
356 | pci_write_config_dword(pdev, AHB_PEXHBASE(i), regs->pexhbase); | |
357 | pci_write_config_dword(pdev, AHB_CRW(i), regs->crw); | |
358 | } | |
359 | out: | |
360 | pci_set_master(pdev); /* Like at boot, enable master on all devices */ | |
361 | } | |
362 | DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_STMICRO, PCI_ANY_ID, resume_mapping); | |
363 | ||
364 | #endif /* CONFIG_PM */ |