1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Synopsys DesignWare PCIe Endpoint controller driver
4 *
5 * Copyright (C) 2017 Texas Instruments
6 * Author: Kishon Vijay Abraham I <kishon@ti.com>
7 */
8
9 #include <linux/of.h>
10 #include <linux/platform_device.h>
11
12 #include "pcie-designware.h"
13 #include <linux/pci-epc.h>
14 #include <linux/pci-epf.h>
15
16 #include "../../pci.h"
17
dw_pcie_ep_linkup(struct dw_pcie_ep * ep)18 void dw_pcie_ep_linkup(struct dw_pcie_ep *ep)
19 {
20 struct pci_epc *epc = ep->epc;
21
22 pci_epc_linkup(epc);
23 }
24 EXPORT_SYMBOL_GPL(dw_pcie_ep_linkup);
25
dw_pcie_ep_init_notify(struct dw_pcie_ep * ep)26 void dw_pcie_ep_init_notify(struct dw_pcie_ep *ep)
27 {
28 struct pci_epc *epc = ep->epc;
29
30 pci_epc_init_notify(epc);
31 }
32 EXPORT_SYMBOL_GPL(dw_pcie_ep_init_notify);
33
34 struct dw_pcie_ep_func *
dw_pcie_ep_get_func_from_ep(struct dw_pcie_ep * ep,u8 func_no)35 dw_pcie_ep_get_func_from_ep(struct dw_pcie_ep *ep, u8 func_no)
36 {
37 struct dw_pcie_ep_func *ep_func;
38
39 list_for_each_entry(ep_func, &ep->func_list, list) {
40 if (ep_func->func_no == func_no)
41 return ep_func;
42 }
43
44 return NULL;
45 }
46
dw_pcie_ep_func_select(struct dw_pcie_ep * ep,u8 func_no)47 static unsigned int dw_pcie_ep_func_select(struct dw_pcie_ep *ep, u8 func_no)
48 {
49 unsigned int func_offset = 0;
50
51 if (ep->ops->func_conf_select)
52 func_offset = ep->ops->func_conf_select(ep, func_no);
53
54 return func_offset;
55 }
56
__dw_pcie_ep_reset_bar(struct dw_pcie * pci,u8 func_no,enum pci_barno bar,int flags)57 static void __dw_pcie_ep_reset_bar(struct dw_pcie *pci, u8 func_no,
58 enum pci_barno bar, int flags)
59 {
60 u32 reg;
61 unsigned int func_offset = 0;
62 struct dw_pcie_ep *ep = &pci->ep;
63
64 func_offset = dw_pcie_ep_func_select(ep, func_no);
65
66 reg = func_offset + PCI_BASE_ADDRESS_0 + (4 * bar);
67 dw_pcie_dbi_ro_wr_en(pci);
68 dw_pcie_writel_dbi2(pci, reg, 0x0);
69 dw_pcie_writel_dbi(pci, reg, 0x0);
70 if (flags & PCI_BASE_ADDRESS_MEM_TYPE_64) {
71 dw_pcie_writel_dbi2(pci, reg + 4, 0x0);
72 dw_pcie_writel_dbi(pci, reg + 4, 0x0);
73 }
74 dw_pcie_dbi_ro_wr_dis(pci);
75 }
76
dw_pcie_ep_reset_bar(struct dw_pcie * pci,enum pci_barno bar)77 void dw_pcie_ep_reset_bar(struct dw_pcie *pci, enum pci_barno bar)
78 {
79 u8 func_no, funcs;
80
81 funcs = pci->ep.epc->max_functions;
82
83 for (func_no = 0; func_no < funcs; func_no++)
84 __dw_pcie_ep_reset_bar(pci, func_no, bar, 0);
85 }
86 EXPORT_SYMBOL_GPL(dw_pcie_ep_reset_bar);
87
__dw_pcie_ep_find_next_cap(struct dw_pcie_ep * ep,u8 func_no,u8 cap_ptr,u8 cap)88 static u8 __dw_pcie_ep_find_next_cap(struct dw_pcie_ep *ep, u8 func_no,
89 u8 cap_ptr, u8 cap)
90 {
91 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
92 unsigned int func_offset = 0;
93 u8 cap_id, next_cap_ptr;
94 u16 reg;
95
96 if (!cap_ptr)
97 return 0;
98
99 func_offset = dw_pcie_ep_func_select(ep, func_no);
100
101 reg = dw_pcie_readw_dbi(pci, func_offset + cap_ptr);
102 cap_id = (reg & 0x00ff);
103
104 if (cap_id > PCI_CAP_ID_MAX)
105 return 0;
106
107 if (cap_id == cap)
108 return cap_ptr;
109
110 next_cap_ptr = (reg & 0xff00) >> 8;
111 return __dw_pcie_ep_find_next_cap(ep, func_no, next_cap_ptr, cap);
112 }
113
dw_pcie_ep_find_capability(struct dw_pcie_ep * ep,u8 func_no,u8 cap)114 static u8 dw_pcie_ep_find_capability(struct dw_pcie_ep *ep, u8 func_no, u8 cap)
115 {
116 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
117 unsigned int func_offset = 0;
118 u8 next_cap_ptr;
119 u16 reg;
120
121 func_offset = dw_pcie_ep_func_select(ep, func_no);
122
123 reg = dw_pcie_readw_dbi(pci, func_offset + PCI_CAPABILITY_LIST);
124 next_cap_ptr = (reg & 0x00ff);
125
126 return __dw_pcie_ep_find_next_cap(ep, func_no, next_cap_ptr, cap);
127 }
128
dw_pcie_ep_write_header(struct pci_epc * epc,u8 func_no,u8 vfunc_no,struct pci_epf_header * hdr)129 static int dw_pcie_ep_write_header(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
130 struct pci_epf_header *hdr)
131 {
132 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
133 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
134 unsigned int func_offset = 0;
135
136 func_offset = dw_pcie_ep_func_select(ep, func_no);
137
138 dw_pcie_dbi_ro_wr_en(pci);
139 dw_pcie_writew_dbi(pci, func_offset + PCI_VENDOR_ID, hdr->vendorid);
140 dw_pcie_writew_dbi(pci, func_offset + PCI_DEVICE_ID, hdr->deviceid);
141 dw_pcie_writeb_dbi(pci, func_offset + PCI_REVISION_ID, hdr->revid);
142 dw_pcie_writeb_dbi(pci, func_offset + PCI_CLASS_PROG, hdr->progif_code);
143 dw_pcie_writew_dbi(pci, func_offset + PCI_CLASS_DEVICE,
144 hdr->subclass_code | hdr->baseclass_code << 8);
145 dw_pcie_writeb_dbi(pci, func_offset + PCI_CACHE_LINE_SIZE,
146 hdr->cache_line_size);
147 dw_pcie_writew_dbi(pci, func_offset + PCI_SUBSYSTEM_VENDOR_ID,
148 hdr->subsys_vendor_id);
149 dw_pcie_writew_dbi(pci, func_offset + PCI_SUBSYSTEM_ID, hdr->subsys_id);
150 dw_pcie_writeb_dbi(pci, func_offset + PCI_INTERRUPT_PIN,
151 hdr->interrupt_pin);
152 dw_pcie_dbi_ro_wr_dis(pci);
153
154 return 0;
155 }
156
dw_pcie_ep_inbound_atu(struct dw_pcie_ep * ep,u8 func_no,int type,dma_addr_t cpu_addr,enum pci_barno bar)157 static int dw_pcie_ep_inbound_atu(struct dw_pcie_ep *ep, u8 func_no, int type,
158 dma_addr_t cpu_addr, enum pci_barno bar)
159 {
160 int ret;
161 u32 free_win;
162 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
163
164 if (!ep->bar_to_atu[bar])
165 free_win = find_first_zero_bit(ep->ib_window_map, pci->num_ib_windows);
166 else
167 free_win = ep->bar_to_atu[bar];
168
169 if (free_win >= pci->num_ib_windows) {
170 dev_err(pci->dev, "No free inbound window\n");
171 return -EINVAL;
172 }
173
174 ret = dw_pcie_prog_inbound_atu(pci, func_no, free_win, type,
175 cpu_addr, bar);
176 if (ret < 0) {
177 dev_err(pci->dev, "Failed to program IB window\n");
178 return ret;
179 }
180
181 ep->bar_to_atu[bar] = free_win;
182 set_bit(free_win, ep->ib_window_map);
183
184 return 0;
185 }
186
dw_pcie_ep_outbound_atu(struct dw_pcie_ep * ep,u8 func_no,phys_addr_t phys_addr,u64 pci_addr,size_t size)187 static int dw_pcie_ep_outbound_atu(struct dw_pcie_ep *ep, u8 func_no,
188 phys_addr_t phys_addr,
189 u64 pci_addr, size_t size)
190 {
191 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
192 u32 free_win;
193 int ret;
194
195 free_win = find_first_zero_bit(ep->ob_window_map, pci->num_ob_windows);
196 if (free_win >= pci->num_ob_windows) {
197 dev_err(pci->dev, "No free outbound window\n");
198 return -EINVAL;
199 }
200
201 ret = dw_pcie_prog_ep_outbound_atu(pci, func_no, free_win, PCIE_ATU_TYPE_MEM,
202 phys_addr, pci_addr, size);
203 if (ret)
204 return ret;
205
206 set_bit(free_win, ep->ob_window_map);
207 ep->outbound_addr[free_win] = phys_addr;
208
209 return 0;
210 }
211
dw_pcie_ep_clear_bar(struct pci_epc * epc,u8 func_no,u8 vfunc_no,struct pci_epf_bar * epf_bar)212 static void dw_pcie_ep_clear_bar(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
213 struct pci_epf_bar *epf_bar)
214 {
215 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
216 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
217 enum pci_barno bar = epf_bar->barno;
218 u32 atu_index = ep->bar_to_atu[bar];
219
220 __dw_pcie_ep_reset_bar(pci, func_no, bar, epf_bar->flags);
221
222 dw_pcie_disable_atu(pci, PCIE_ATU_REGION_DIR_IB, atu_index);
223 clear_bit(atu_index, ep->ib_window_map);
224 ep->epf_bar[bar] = NULL;
225 ep->bar_to_atu[bar] = 0;
226 }
227
dw_pcie_ep_set_bar(struct pci_epc * epc,u8 func_no,u8 vfunc_no,struct pci_epf_bar * epf_bar)228 static int dw_pcie_ep_set_bar(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
229 struct pci_epf_bar *epf_bar)
230 {
231 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
232 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
233 enum pci_barno bar = epf_bar->barno;
234 size_t size = epf_bar->size;
235 int flags = epf_bar->flags;
236 unsigned int func_offset = 0;
237 int ret, type;
238 u32 reg;
239
240 func_offset = dw_pcie_ep_func_select(ep, func_no);
241
242 reg = PCI_BASE_ADDRESS_0 + (4 * bar) + func_offset;
243
244 if (!(flags & PCI_BASE_ADDRESS_SPACE))
245 type = PCIE_ATU_TYPE_MEM;
246 else
247 type = PCIE_ATU_TYPE_IO;
248
249 ret = dw_pcie_ep_inbound_atu(ep, func_no, type, epf_bar->phys_addr, bar);
250 if (ret)
251 return ret;
252
253 if (ep->epf_bar[bar])
254 return 0;
255
256 dw_pcie_dbi_ro_wr_en(pci);
257
258 dw_pcie_writel_dbi2(pci, reg, lower_32_bits(size - 1));
259 dw_pcie_writel_dbi(pci, reg, flags);
260
261 if (flags & PCI_BASE_ADDRESS_MEM_TYPE_64) {
262 dw_pcie_writel_dbi2(pci, reg + 4, upper_32_bits(size - 1));
263 dw_pcie_writel_dbi(pci, reg + 4, 0);
264 }
265
266 ep->epf_bar[bar] = epf_bar;
267 dw_pcie_dbi_ro_wr_dis(pci);
268
269 return 0;
270 }
271
dw_pcie_find_index(struct dw_pcie_ep * ep,phys_addr_t addr,u32 * atu_index)272 static int dw_pcie_find_index(struct dw_pcie_ep *ep, phys_addr_t addr,
273 u32 *atu_index)
274 {
275 u32 index;
276 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
277
278 for (index = 0; index < pci->num_ob_windows; index++) {
279 if (ep->outbound_addr[index] != addr)
280 continue;
281 *atu_index = index;
282 return 0;
283 }
284
285 return -EINVAL;
286 }
287
dw_pcie_ep_unmap_addr(struct pci_epc * epc,u8 func_no,u8 vfunc_no,phys_addr_t addr)288 static void dw_pcie_ep_unmap_addr(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
289 phys_addr_t addr)
290 {
291 int ret;
292 u32 atu_index;
293 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
294 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
295
296 ret = dw_pcie_find_index(ep, addr, &atu_index);
297 if (ret < 0)
298 return;
299
300 dw_pcie_disable_atu(pci, PCIE_ATU_REGION_DIR_OB, atu_index);
301 clear_bit(atu_index, ep->ob_window_map);
302 }
303
dw_pcie_ep_map_addr(struct pci_epc * epc,u8 func_no,u8 vfunc_no,phys_addr_t addr,u64 pci_addr,size_t size)304 static int dw_pcie_ep_map_addr(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
305 phys_addr_t addr, u64 pci_addr, size_t size)
306 {
307 int ret;
308 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
309 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
310
311 ret = dw_pcie_ep_outbound_atu(ep, func_no, addr, pci_addr, size);
312 if (ret) {
313 dev_err(pci->dev, "Failed to enable address\n");
314 return ret;
315 }
316
317 return 0;
318 }
319
dw_pcie_ep_get_msi(struct pci_epc * epc,u8 func_no,u8 vfunc_no)320 static int dw_pcie_ep_get_msi(struct pci_epc *epc, u8 func_no, u8 vfunc_no)
321 {
322 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
323 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
324 u32 val, reg;
325 unsigned int func_offset = 0;
326 struct dw_pcie_ep_func *ep_func;
327
328 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
329 if (!ep_func || !ep_func->msi_cap)
330 return -EINVAL;
331
332 func_offset = dw_pcie_ep_func_select(ep, func_no);
333
334 reg = ep_func->msi_cap + func_offset + PCI_MSI_FLAGS;
335 val = dw_pcie_readw_dbi(pci, reg);
336 if (!(val & PCI_MSI_FLAGS_ENABLE))
337 return -EINVAL;
338
339 val = (val & PCI_MSI_FLAGS_QSIZE) >> 4;
340
341 return val;
342 }
343
dw_pcie_ep_set_msi(struct pci_epc * epc,u8 func_no,u8 vfunc_no,u8 interrupts)344 static int dw_pcie_ep_set_msi(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
345 u8 interrupts)
346 {
347 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
348 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
349 u32 val, reg;
350 unsigned int func_offset = 0;
351 struct dw_pcie_ep_func *ep_func;
352
353 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
354 if (!ep_func || !ep_func->msi_cap)
355 return -EINVAL;
356
357 func_offset = dw_pcie_ep_func_select(ep, func_no);
358
359 reg = ep_func->msi_cap + func_offset + PCI_MSI_FLAGS;
360 val = dw_pcie_readw_dbi(pci, reg);
361 val &= ~PCI_MSI_FLAGS_QMASK;
362 val |= (interrupts << 1) & PCI_MSI_FLAGS_QMASK;
363 dw_pcie_dbi_ro_wr_en(pci);
364 dw_pcie_writew_dbi(pci, reg, val);
365 dw_pcie_dbi_ro_wr_dis(pci);
366
367 return 0;
368 }
369
dw_pcie_ep_get_msix(struct pci_epc * epc,u8 func_no,u8 vfunc_no)370 static int dw_pcie_ep_get_msix(struct pci_epc *epc, u8 func_no, u8 vfunc_no)
371 {
372 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
373 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
374 u32 val, reg;
375 unsigned int func_offset = 0;
376 struct dw_pcie_ep_func *ep_func;
377
378 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
379 if (!ep_func || !ep_func->msix_cap)
380 return -EINVAL;
381
382 func_offset = dw_pcie_ep_func_select(ep, func_no);
383
384 reg = ep_func->msix_cap + func_offset + PCI_MSIX_FLAGS;
385 val = dw_pcie_readw_dbi(pci, reg);
386 if (!(val & PCI_MSIX_FLAGS_ENABLE))
387 return -EINVAL;
388
389 val &= PCI_MSIX_FLAGS_QSIZE;
390
391 return val;
392 }
393
dw_pcie_ep_set_msix(struct pci_epc * epc,u8 func_no,u8 vfunc_no,u16 interrupts,enum pci_barno bir,u32 offset)394 static int dw_pcie_ep_set_msix(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
395 u16 interrupts, enum pci_barno bir, u32 offset)
396 {
397 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
398 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
399 u32 val, reg;
400 unsigned int func_offset = 0;
401 struct dw_pcie_ep_func *ep_func;
402
403 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
404 if (!ep_func || !ep_func->msix_cap)
405 return -EINVAL;
406
407 dw_pcie_dbi_ro_wr_en(pci);
408
409 func_offset = dw_pcie_ep_func_select(ep, func_no);
410
411 reg = ep_func->msix_cap + func_offset + PCI_MSIX_FLAGS;
412 val = dw_pcie_readw_dbi(pci, reg);
413 val &= ~PCI_MSIX_FLAGS_QSIZE;
414 val |= interrupts;
415 dw_pcie_writew_dbi(pci, reg, val);
416
417 reg = ep_func->msix_cap + func_offset + PCI_MSIX_TABLE;
418 val = offset | bir;
419 dw_pcie_writel_dbi(pci, reg, val);
420
421 reg = ep_func->msix_cap + func_offset + PCI_MSIX_PBA;
422 val = (offset + (interrupts * PCI_MSIX_ENTRY_SIZE)) | bir;
423 dw_pcie_writel_dbi(pci, reg, val);
424
425 dw_pcie_dbi_ro_wr_dis(pci);
426
427 return 0;
428 }
429
dw_pcie_ep_raise_irq(struct pci_epc * epc,u8 func_no,u8 vfunc_no,enum pci_epc_irq_type type,u16 interrupt_num)430 static int dw_pcie_ep_raise_irq(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
431 enum pci_epc_irq_type type, u16 interrupt_num)
432 {
433 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
434
435 if (!ep->ops->raise_irq)
436 return -EINVAL;
437
438 return ep->ops->raise_irq(ep, func_no, type, interrupt_num);
439 }
440
dw_pcie_ep_stop(struct pci_epc * epc)441 static void dw_pcie_ep_stop(struct pci_epc *epc)
442 {
443 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
444 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
445
446 dw_pcie_stop_link(pci);
447 }
448
dw_pcie_ep_start(struct pci_epc * epc)449 static int dw_pcie_ep_start(struct pci_epc *epc)
450 {
451 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
452 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
453
454 return dw_pcie_start_link(pci);
455 }
456
457 static const struct pci_epc_features*
dw_pcie_ep_get_features(struct pci_epc * epc,u8 func_no,u8 vfunc_no)458 dw_pcie_ep_get_features(struct pci_epc *epc, u8 func_no, u8 vfunc_no)
459 {
460 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
461
462 if (!ep->ops->get_features)
463 return NULL;
464
465 return ep->ops->get_features(ep);
466 }
467
468 static const struct pci_epc_ops epc_ops = {
469 .write_header = dw_pcie_ep_write_header,
470 .set_bar = dw_pcie_ep_set_bar,
471 .clear_bar = dw_pcie_ep_clear_bar,
472 .map_addr = dw_pcie_ep_map_addr,
473 .unmap_addr = dw_pcie_ep_unmap_addr,
474 .set_msi = dw_pcie_ep_set_msi,
475 .get_msi = dw_pcie_ep_get_msi,
476 .set_msix = dw_pcie_ep_set_msix,
477 .get_msix = dw_pcie_ep_get_msix,
478 .raise_irq = dw_pcie_ep_raise_irq,
479 .start = dw_pcie_ep_start,
480 .stop = dw_pcie_ep_stop,
481 .get_features = dw_pcie_ep_get_features,
482 };
483
dw_pcie_ep_raise_legacy_irq(struct dw_pcie_ep * ep,u8 func_no)484 int dw_pcie_ep_raise_legacy_irq(struct dw_pcie_ep *ep, u8 func_no)
485 {
486 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
487 struct device *dev = pci->dev;
488
489 dev_err(dev, "EP cannot trigger legacy IRQs\n");
490
491 return -EINVAL;
492 }
493 EXPORT_SYMBOL_GPL(dw_pcie_ep_raise_legacy_irq);
494
dw_pcie_ep_raise_msi_irq(struct dw_pcie_ep * ep,u8 func_no,u8 interrupt_num)495 int dw_pcie_ep_raise_msi_irq(struct dw_pcie_ep *ep, u8 func_no,
496 u8 interrupt_num)
497 {
498 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
499 struct dw_pcie_ep_func *ep_func;
500 struct pci_epc *epc = ep->epc;
501 unsigned int aligned_offset;
502 unsigned int func_offset = 0;
503 u16 msg_ctrl, msg_data;
504 u32 msg_addr_lower, msg_addr_upper, reg;
505 u64 msg_addr;
506 bool has_upper;
507 int ret;
508
509 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
510 if (!ep_func || !ep_func->msi_cap)
511 return -EINVAL;
512
513 func_offset = dw_pcie_ep_func_select(ep, func_no);
514
515 /* Raise MSI per the PCI Local Bus Specification Revision 3.0, 6.8.1. */
516 reg = ep_func->msi_cap + func_offset + PCI_MSI_FLAGS;
517 msg_ctrl = dw_pcie_readw_dbi(pci, reg);
518 has_upper = !!(msg_ctrl & PCI_MSI_FLAGS_64BIT);
519 reg = ep_func->msi_cap + func_offset + PCI_MSI_ADDRESS_LO;
520 msg_addr_lower = dw_pcie_readl_dbi(pci, reg);
521 if (has_upper) {
522 reg = ep_func->msi_cap + func_offset + PCI_MSI_ADDRESS_HI;
523 msg_addr_upper = dw_pcie_readl_dbi(pci, reg);
524 reg = ep_func->msi_cap + func_offset + PCI_MSI_DATA_64;
525 msg_data = dw_pcie_readw_dbi(pci, reg);
526 } else {
527 msg_addr_upper = 0;
528 reg = ep_func->msi_cap + func_offset + PCI_MSI_DATA_32;
529 msg_data = dw_pcie_readw_dbi(pci, reg);
530 }
531 aligned_offset = msg_addr_lower & (epc->mem->window.page_size - 1);
532 msg_addr = ((u64)msg_addr_upper) << 32 |
533 (msg_addr_lower & ~aligned_offset);
534 ret = dw_pcie_ep_map_addr(epc, func_no, 0, ep->msi_mem_phys, msg_addr,
535 epc->mem->window.page_size);
536 if (ret)
537 return ret;
538
539 writel(msg_data | (interrupt_num - 1), ep->msi_mem + aligned_offset);
540
541 dw_pcie_ep_unmap_addr(epc, func_no, 0, ep->msi_mem_phys);
542
543 return 0;
544 }
545 EXPORT_SYMBOL_GPL(dw_pcie_ep_raise_msi_irq);
546
dw_pcie_ep_raise_msix_irq_doorbell(struct dw_pcie_ep * ep,u8 func_no,u16 interrupt_num)547 int dw_pcie_ep_raise_msix_irq_doorbell(struct dw_pcie_ep *ep, u8 func_no,
548 u16 interrupt_num)
549 {
550 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
551 struct dw_pcie_ep_func *ep_func;
552 u32 msg_data;
553
554 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
555 if (!ep_func || !ep_func->msix_cap)
556 return -EINVAL;
557
558 msg_data = (func_no << PCIE_MSIX_DOORBELL_PF_SHIFT) |
559 (interrupt_num - 1);
560
561 dw_pcie_writel_dbi(pci, PCIE_MSIX_DOORBELL, msg_data);
562
563 return 0;
564 }
565
dw_pcie_ep_raise_msix_irq(struct dw_pcie_ep * ep,u8 func_no,u16 interrupt_num)566 int dw_pcie_ep_raise_msix_irq(struct dw_pcie_ep *ep, u8 func_no,
567 u16 interrupt_num)
568 {
569 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
570 struct dw_pcie_ep_func *ep_func;
571 struct pci_epf_msix_tbl *msix_tbl;
572 struct pci_epc *epc = ep->epc;
573 unsigned int func_offset = 0;
574 u32 reg, msg_data, vec_ctrl;
575 unsigned int aligned_offset;
576 u32 tbl_offset;
577 u64 msg_addr;
578 int ret;
579 u8 bir;
580
581 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
582 if (!ep_func || !ep_func->msix_cap)
583 return -EINVAL;
584
585 func_offset = dw_pcie_ep_func_select(ep, func_no);
586
587 reg = ep_func->msix_cap + func_offset + PCI_MSIX_TABLE;
588 tbl_offset = dw_pcie_readl_dbi(pci, reg);
589 bir = (tbl_offset & PCI_MSIX_TABLE_BIR);
590 tbl_offset &= PCI_MSIX_TABLE_OFFSET;
591
592 msix_tbl = ep->epf_bar[bir]->addr + tbl_offset;
593 msg_addr = msix_tbl[(interrupt_num - 1)].msg_addr;
594 msg_data = msix_tbl[(interrupt_num - 1)].msg_data;
595 vec_ctrl = msix_tbl[(interrupt_num - 1)].vector_ctrl;
596
597 if (vec_ctrl & PCI_MSIX_ENTRY_CTRL_MASKBIT) {
598 dev_dbg(pci->dev, "MSI-X entry ctrl set\n");
599 return -EPERM;
600 }
601
602 aligned_offset = msg_addr & (epc->mem->window.page_size - 1);
603 ret = dw_pcie_ep_map_addr(epc, func_no, 0, ep->msi_mem_phys, msg_addr,
604 epc->mem->window.page_size);
605 if (ret)
606 return ret;
607
608 writel(msg_data, ep->msi_mem + aligned_offset);
609
610 dw_pcie_ep_unmap_addr(epc, func_no, 0, ep->msi_mem_phys);
611
612 return 0;
613 }
614
dw_pcie_ep_exit(struct dw_pcie_ep * ep)615 void dw_pcie_ep_exit(struct dw_pcie_ep *ep)
616 {
617 struct pci_epc *epc = ep->epc;
618
619 pci_epc_mem_free_addr(epc, ep->msi_mem_phys, ep->msi_mem,
620 epc->mem->window.page_size);
621
622 pci_epc_mem_exit(epc);
623 }
624
dw_pcie_ep_find_ext_capability(struct dw_pcie * pci,int cap)625 static unsigned int dw_pcie_ep_find_ext_capability(struct dw_pcie *pci, int cap)
626 {
627 u32 header;
628 int pos = PCI_CFG_SPACE_SIZE;
629
630 while (pos) {
631 header = dw_pcie_readl_dbi(pci, pos);
632 if (PCI_EXT_CAP_ID(header) == cap)
633 return pos;
634
635 pos = PCI_EXT_CAP_NEXT(header);
636 if (!pos)
637 break;
638 }
639
640 return 0;
641 }
642
dw_pcie_ep_init_complete(struct dw_pcie_ep * ep)643 int dw_pcie_ep_init_complete(struct dw_pcie_ep *ep)
644 {
645 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
646 unsigned int offset;
647 unsigned int nbars;
648 u8 hdr_type;
649 u32 reg;
650 int i;
651
652 hdr_type = dw_pcie_readb_dbi(pci, PCI_HEADER_TYPE) &
653 PCI_HEADER_TYPE_MASK;
654 if (hdr_type != PCI_HEADER_TYPE_NORMAL) {
655 dev_err(pci->dev,
656 "PCIe controller is not set to EP mode (hdr_type:0x%x)!\n",
657 hdr_type);
658 return -EIO;
659 }
660
661 offset = dw_pcie_ep_find_ext_capability(pci, PCI_EXT_CAP_ID_REBAR);
662
663 dw_pcie_dbi_ro_wr_en(pci);
664
665 if (offset) {
666 reg = dw_pcie_readl_dbi(pci, offset + PCI_REBAR_CTRL);
667 nbars = (reg & PCI_REBAR_CTRL_NBAR_MASK) >>
668 PCI_REBAR_CTRL_NBAR_SHIFT;
669
670 for (i = 0; i < nbars; i++, offset += PCI_REBAR_CTRL)
671 dw_pcie_writel_dbi(pci, offset + PCI_REBAR_CAP, 0x0);
672 }
673
674 dw_pcie_setup(pci);
675 dw_pcie_dbi_ro_wr_dis(pci);
676
677 return 0;
678 }
679 EXPORT_SYMBOL_GPL(dw_pcie_ep_init_complete);
680
dw_pcie_ep_init(struct dw_pcie_ep * ep)681 int dw_pcie_ep_init(struct dw_pcie_ep *ep)
682 {
683 int ret;
684 void *addr;
685 u8 func_no;
686 struct resource *res;
687 struct pci_epc *epc;
688 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
689 struct device *dev = pci->dev;
690 struct platform_device *pdev = to_platform_device(dev);
691 struct device_node *np = dev->of_node;
692 const struct pci_epc_features *epc_features;
693 struct dw_pcie_ep_func *ep_func;
694
695 INIT_LIST_HEAD(&ep->func_list);
696
697 if (!pci->dbi_base) {
698 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dbi");
699 pci->dbi_base = devm_pci_remap_cfg_resource(dev, res);
700 if (IS_ERR(pci->dbi_base))
701 return PTR_ERR(pci->dbi_base);
702 }
703
704 if (!pci->dbi_base2) {
705 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dbi2");
706 if (!res) {
707 pci->dbi_base2 = pci->dbi_base + SZ_4K;
708 } else {
709 pci->dbi_base2 = devm_pci_remap_cfg_resource(dev, res);
710 if (IS_ERR(pci->dbi_base2))
711 return PTR_ERR(pci->dbi_base2);
712 }
713 }
714
715 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "addr_space");
716 if (!res)
717 return -EINVAL;
718
719 ep->phys_base = res->start;
720 ep->addr_size = resource_size(res);
721
722 dw_pcie_version_detect(pci);
723
724 dw_pcie_iatu_detect(pci);
725
726 ep->ib_window_map = devm_bitmap_zalloc(dev, pci->num_ib_windows,
727 GFP_KERNEL);
728 if (!ep->ib_window_map)
729 return -ENOMEM;
730
731 ep->ob_window_map = devm_bitmap_zalloc(dev, pci->num_ob_windows,
732 GFP_KERNEL);
733 if (!ep->ob_window_map)
734 return -ENOMEM;
735
736 addr = devm_kcalloc(dev, pci->num_ob_windows, sizeof(phys_addr_t),
737 GFP_KERNEL);
738 if (!addr)
739 return -ENOMEM;
740 ep->outbound_addr = addr;
741
742 if (pci->link_gen < 1)
743 pci->link_gen = of_pci_get_max_link_speed(np);
744
745 epc = devm_pci_epc_create(dev, &epc_ops);
746 if (IS_ERR(epc)) {
747 dev_err(dev, "Failed to create epc device\n");
748 return PTR_ERR(epc);
749 }
750
751 ep->epc = epc;
752 epc_set_drvdata(epc, ep);
753
754 ret = of_property_read_u8(np, "max-functions", &epc->max_functions);
755 if (ret < 0)
756 epc->max_functions = 1;
757
758 for (func_no = 0; func_no < epc->max_functions; func_no++) {
759 ep_func = devm_kzalloc(dev, sizeof(*ep_func), GFP_KERNEL);
760 if (!ep_func)
761 return -ENOMEM;
762
763 ep_func->func_no = func_no;
764 ep_func->msi_cap = dw_pcie_ep_find_capability(ep, func_no,
765 PCI_CAP_ID_MSI);
766 ep_func->msix_cap = dw_pcie_ep_find_capability(ep, func_no,
767 PCI_CAP_ID_MSIX);
768
769 list_add_tail(&ep_func->list, &ep->func_list);
770 }
771
772 if (ep->ops->ep_init)
773 ep->ops->ep_init(ep);
774
775 ret = pci_epc_mem_init(epc, ep->phys_base, ep->addr_size,
776 ep->page_size);
777 if (ret < 0) {
778 dev_err(dev, "Failed to initialize address space\n");
779 return ret;
780 }
781
782 ep->msi_mem = pci_epc_mem_alloc_addr(epc, &ep->msi_mem_phys,
783 epc->mem->window.page_size);
784 if (!ep->msi_mem) {
785 ret = -ENOMEM;
786 dev_err(dev, "Failed to reserve memory for MSI/MSI-X\n");
787 goto err_exit_epc_mem;
788 }
789
790 if (ep->ops->get_features) {
791 epc_features = ep->ops->get_features(ep);
792 if (epc_features->core_init_notifier)
793 return 0;
794 }
795
796 ret = dw_pcie_ep_init_complete(ep);
797 if (ret)
798 goto err_free_epc_mem;
799
800 return 0;
801
802 err_free_epc_mem:
803 pci_epc_mem_free_addr(epc, ep->msi_mem_phys, ep->msi_mem,
804 epc->mem->window.page_size);
805
806 err_exit_epc_mem:
807 pci_epc_mem_exit(epc);
808
809 return ret;
810 }
811 EXPORT_SYMBOL_GPL(dw_pcie_ep_init);
812
