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