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];
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 ep->bar_to_atu[bar] = free_win;
181 set_bit(free_win, ep->ib_window_map);
182
183 return 0;
184 }
185
dw_pcie_ep_outbound_atu(struct dw_pcie_ep * ep,u8 func_no,phys_addr_t phys_addr,u64 pci_addr,size_t size)186 static int dw_pcie_ep_outbound_atu(struct dw_pcie_ep *ep, u8 func_no,
187 phys_addr_t phys_addr,
188 u64 pci_addr, size_t size)
189 {
190 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
191 u32 free_win;
192 int ret;
193
194 free_win = find_first_zero_bit(ep->ob_window_map, pci->num_ob_windows);
195 if (free_win >= pci->num_ob_windows) {
196 dev_err(pci->dev, "No free outbound window\n");
197 return -EINVAL;
198 }
199
200 ret = dw_pcie_prog_ep_outbound_atu(pci, func_no, free_win, PCIE_ATU_TYPE_MEM,
201 phys_addr, pci_addr, size);
202 if (ret)
203 return ret;
204
205 set_bit(free_win, ep->ob_window_map);
206 ep->outbound_addr[free_win] = phys_addr;
207
208 return 0;
209 }
210
dw_pcie_ep_clear_bar(struct pci_epc * epc,u8 func_no,u8 vfunc_no,struct pci_epf_bar * epf_bar)211 static void dw_pcie_ep_clear_bar(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
212 struct pci_epf_bar *epf_bar)
213 {
214 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
215 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
216 enum pci_barno bar = epf_bar->barno;
217 u32 atu_index = ep->bar_to_atu[bar];
218
219 __dw_pcie_ep_reset_bar(pci, func_no, bar, epf_bar->flags);
220
221 dw_pcie_disable_atu(pci, PCIE_ATU_REGION_DIR_IB, atu_index);
222 clear_bit(atu_index, ep->ib_window_map);
223 ep->epf_bar[bar] = NULL;
224 ep->bar_to_atu[bar] = 0;
225 }
226
dw_pcie_ep_set_bar(struct pci_epc * epc,u8 func_no,u8 vfunc_no,struct pci_epf_bar * epf_bar)227 static int dw_pcie_ep_set_bar(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
228 struct pci_epf_bar *epf_bar)
229 {
230 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
231 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
232 enum pci_barno bar = epf_bar->barno;
233 size_t size = epf_bar->size;
234 int flags = epf_bar->flags;
235 unsigned int func_offset = 0;
236 int ret, type;
237 u32 reg;
238
239 func_offset = dw_pcie_ep_func_select(ep, func_no);
240
241 reg = PCI_BASE_ADDRESS_0 + (4 * bar) + func_offset;
242
243 if (!(flags & PCI_BASE_ADDRESS_SPACE))
244 type = PCIE_ATU_TYPE_MEM;
245 else
246 type = PCIE_ATU_TYPE_IO;
247
248 ret = dw_pcie_ep_inbound_atu(ep, func_no, type, epf_bar->phys_addr, bar);
249 if (ret)
250 return ret;
251
252 if (ep->epf_bar[bar])
253 return 0;
254
255 dw_pcie_dbi_ro_wr_en(pci);
256
257 dw_pcie_writel_dbi2(pci, reg, lower_32_bits(size - 1));
258 dw_pcie_writel_dbi(pci, reg, flags);
259
260 if (flags & PCI_BASE_ADDRESS_MEM_TYPE_64) {
261 dw_pcie_writel_dbi2(pci, reg + 4, upper_32_bits(size - 1));
262 dw_pcie_writel_dbi(pci, reg + 4, 0);
263 }
264
265 ep->epf_bar[bar] = epf_bar;
266 dw_pcie_dbi_ro_wr_dis(pci);
267
268 return 0;
269 }
270
dw_pcie_find_index(struct dw_pcie_ep * ep,phys_addr_t addr,u32 * atu_index)271 static int dw_pcie_find_index(struct dw_pcie_ep *ep, phys_addr_t addr,
272 u32 *atu_index)
273 {
274 u32 index;
275 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
276
277 for (index = 0; index < pci->num_ob_windows; index++) {
278 if (ep->outbound_addr[index] != addr)
279 continue;
280 *atu_index = index;
281 return 0;
282 }
283
284 return -EINVAL;
285 }
286
dw_pcie_ep_unmap_addr(struct pci_epc * epc,u8 func_no,u8 vfunc_no,phys_addr_t addr)287 static void dw_pcie_ep_unmap_addr(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
288 phys_addr_t addr)
289 {
290 int ret;
291 u32 atu_index;
292 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
293 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
294
295 ret = dw_pcie_find_index(ep, addr, &atu_index);
296 if (ret < 0)
297 return;
298
299 dw_pcie_disable_atu(pci, PCIE_ATU_REGION_DIR_OB, atu_index);
300 clear_bit(atu_index, ep->ob_window_map);
301 }
302
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)303 static int dw_pcie_ep_map_addr(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
304 phys_addr_t addr, u64 pci_addr, size_t size)
305 {
306 int ret;
307 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
308 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
309
310 ret = dw_pcie_ep_outbound_atu(ep, func_no, addr, pci_addr, size);
311 if (ret) {
312 dev_err(pci->dev, "Failed to enable address\n");
313 return ret;
314 }
315
316 return 0;
317 }
318
dw_pcie_ep_get_msi(struct pci_epc * epc,u8 func_no,u8 vfunc_no)319 static int dw_pcie_ep_get_msi(struct pci_epc *epc, u8 func_no, u8 vfunc_no)
320 {
321 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
322 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
323 u32 val, reg;
324 unsigned int func_offset = 0;
325 struct dw_pcie_ep_func *ep_func;
326
327 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
328 if (!ep_func || !ep_func->msi_cap)
329 return -EINVAL;
330
331 func_offset = dw_pcie_ep_func_select(ep, func_no);
332
333 reg = ep_func->msi_cap + func_offset + PCI_MSI_FLAGS;
334 val = dw_pcie_readw_dbi(pci, reg);
335 if (!(val & PCI_MSI_FLAGS_ENABLE))
336 return -EINVAL;
337
338 val = (val & PCI_MSI_FLAGS_QSIZE) >> 4;
339
340 return val;
341 }
342
dw_pcie_ep_set_msi(struct pci_epc * epc,u8 func_no,u8 vfunc_no,u8 interrupts)343 static int dw_pcie_ep_set_msi(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
344 u8 interrupts)
345 {
346 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
347 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
348 u32 val, reg;
349 unsigned int func_offset = 0;
350 struct dw_pcie_ep_func *ep_func;
351
352 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
353 if (!ep_func || !ep_func->msi_cap)
354 return -EINVAL;
355
356 func_offset = dw_pcie_ep_func_select(ep, func_no);
357
358 reg = ep_func->msi_cap + func_offset + PCI_MSI_FLAGS;
359 val = dw_pcie_readw_dbi(pci, reg);
360 val &= ~PCI_MSI_FLAGS_QMASK;
361 val |= (interrupts << 1) & PCI_MSI_FLAGS_QMASK;
362 dw_pcie_dbi_ro_wr_en(pci);
363 dw_pcie_writew_dbi(pci, reg, val);
364 dw_pcie_dbi_ro_wr_dis(pci);
365
366 return 0;
367 }
368
dw_pcie_ep_get_msix(struct pci_epc * epc,u8 func_no,u8 vfunc_no)369 static int dw_pcie_ep_get_msix(struct pci_epc *epc, u8 func_no, u8 vfunc_no)
370 {
371 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
372 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
373 u32 val, reg;
374 unsigned int func_offset = 0;
375 struct dw_pcie_ep_func *ep_func;
376
377 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
378 if (!ep_func || !ep_func->msix_cap)
379 return -EINVAL;
380
381 func_offset = dw_pcie_ep_func_select(ep, func_no);
382
383 reg = ep_func->msix_cap + func_offset + PCI_MSIX_FLAGS;
384 val = dw_pcie_readw_dbi(pci, reg);
385 if (!(val & PCI_MSIX_FLAGS_ENABLE))
386 return -EINVAL;
387
388 val &= PCI_MSIX_FLAGS_QSIZE;
389
390 return val;
391 }
392
dw_pcie_ep_set_msix(struct pci_epc * epc,u8 func_no,u8 vfunc_no,u16 interrupts,enum pci_barno bir,u32 offset)393 static int dw_pcie_ep_set_msix(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
394 u16 interrupts, enum pci_barno bir, u32 offset)
395 {
396 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
397 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
398 u32 val, reg;
399 unsigned int func_offset = 0;
400 struct dw_pcie_ep_func *ep_func;
401
402 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
403 if (!ep_func || !ep_func->msix_cap)
404 return -EINVAL;
405
406 dw_pcie_dbi_ro_wr_en(pci);
407
408 func_offset = dw_pcie_ep_func_select(ep, func_no);
409
410 reg = ep_func->msix_cap + func_offset + PCI_MSIX_FLAGS;
411 val = dw_pcie_readw_dbi(pci, reg);
412 val &= ~PCI_MSIX_FLAGS_QSIZE;
413 val |= interrupts;
414 dw_pcie_writew_dbi(pci, reg, val);
415
416 reg = ep_func->msix_cap + func_offset + PCI_MSIX_TABLE;
417 val = offset | bir;
418 dw_pcie_writel_dbi(pci, reg, val);
419
420 reg = ep_func->msix_cap + func_offset + PCI_MSIX_PBA;
421 val = (offset + (interrupts * PCI_MSIX_ENTRY_SIZE)) | bir;
422 dw_pcie_writel_dbi(pci, reg, val);
423
424 dw_pcie_dbi_ro_wr_dis(pci);
425
426 return 0;
427 }
428
dw_pcie_ep_raise_irq(struct pci_epc * epc,u8 func_no,u8 vfunc_no,enum pci_epc_irq_type type,u16 interrupt_num)429 static int dw_pcie_ep_raise_irq(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
430 enum pci_epc_irq_type type, u16 interrupt_num)
431 {
432 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
433
434 if (!ep->ops->raise_irq)
435 return -EINVAL;
436
437 return ep->ops->raise_irq(ep, func_no, type, interrupt_num);
438 }
439
dw_pcie_ep_stop(struct pci_epc * epc)440 static void dw_pcie_ep_stop(struct pci_epc *epc)
441 {
442 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
443 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
444
445 dw_pcie_stop_link(pci);
446 }
447
dw_pcie_ep_start(struct pci_epc * epc)448 static int dw_pcie_ep_start(struct pci_epc *epc)
449 {
450 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
451 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
452
453 return dw_pcie_start_link(pci);
454 }
455
456 static const struct pci_epc_features*
dw_pcie_ep_get_features(struct pci_epc * epc,u8 func_no,u8 vfunc_no)457 dw_pcie_ep_get_features(struct pci_epc *epc, u8 func_no, u8 vfunc_no)
458 {
459 struct dw_pcie_ep *ep = epc_get_drvdata(epc);
460
461 if (!ep->ops->get_features)
462 return NULL;
463
464 return ep->ops->get_features(ep);
465 }
466
467 static const struct pci_epc_ops epc_ops = {
468 .write_header = dw_pcie_ep_write_header,
469 .set_bar = dw_pcie_ep_set_bar,
470 .clear_bar = dw_pcie_ep_clear_bar,
471 .map_addr = dw_pcie_ep_map_addr,
472 .unmap_addr = dw_pcie_ep_unmap_addr,
473 .set_msi = dw_pcie_ep_set_msi,
474 .get_msi = dw_pcie_ep_get_msi,
475 .set_msix = dw_pcie_ep_set_msix,
476 .get_msix = dw_pcie_ep_get_msix,
477 .raise_irq = dw_pcie_ep_raise_irq,
478 .start = dw_pcie_ep_start,
479 .stop = dw_pcie_ep_stop,
480 .get_features = dw_pcie_ep_get_features,
481 };
482
dw_pcie_ep_raise_legacy_irq(struct dw_pcie_ep * ep,u8 func_no)483 int dw_pcie_ep_raise_legacy_irq(struct dw_pcie_ep *ep, u8 func_no)
484 {
485 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
486 struct device *dev = pci->dev;
487
488 dev_err(dev, "EP cannot trigger legacy IRQs\n");
489
490 return -EINVAL;
491 }
492 EXPORT_SYMBOL_GPL(dw_pcie_ep_raise_legacy_irq);
493
dw_pcie_ep_raise_msi_irq(struct dw_pcie_ep * ep,u8 func_no,u8 interrupt_num)494 int dw_pcie_ep_raise_msi_irq(struct dw_pcie_ep *ep, u8 func_no,
495 u8 interrupt_num)
496 {
497 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
498 struct dw_pcie_ep_func *ep_func;
499 struct pci_epc *epc = ep->epc;
500 unsigned int aligned_offset;
501 unsigned int func_offset = 0;
502 u16 msg_ctrl, msg_data;
503 u32 msg_addr_lower, msg_addr_upper, reg;
504 u64 msg_addr;
505 bool has_upper;
506 int ret;
507
508 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
509 if (!ep_func || !ep_func->msi_cap)
510 return -EINVAL;
511
512 func_offset = dw_pcie_ep_func_select(ep, func_no);
513
514 /* Raise MSI per the PCI Local Bus Specification Revision 3.0, 6.8.1. */
515 reg = ep_func->msi_cap + func_offset + PCI_MSI_FLAGS;
516 msg_ctrl = dw_pcie_readw_dbi(pci, reg);
517 has_upper = !!(msg_ctrl & PCI_MSI_FLAGS_64BIT);
518 reg = ep_func->msi_cap + func_offset + PCI_MSI_ADDRESS_LO;
519 msg_addr_lower = dw_pcie_readl_dbi(pci, reg);
520 if (has_upper) {
521 reg = ep_func->msi_cap + func_offset + PCI_MSI_ADDRESS_HI;
522 msg_addr_upper = dw_pcie_readl_dbi(pci, reg);
523 reg = ep_func->msi_cap + func_offset + PCI_MSI_DATA_64;
524 msg_data = dw_pcie_readw_dbi(pci, reg);
525 } else {
526 msg_addr_upper = 0;
527 reg = ep_func->msi_cap + func_offset + PCI_MSI_DATA_32;
528 msg_data = dw_pcie_readw_dbi(pci, reg);
529 }
530 aligned_offset = msg_addr_lower & (epc->mem->window.page_size - 1);
531 msg_addr = ((u64)msg_addr_upper) << 32 |
532 (msg_addr_lower & ~aligned_offset);
533 ret = dw_pcie_ep_map_addr(epc, func_no, 0, ep->msi_mem_phys, msg_addr,
534 epc->mem->window.page_size);
535 if (ret)
536 return ret;
537
538 writel(msg_data | (interrupt_num - 1), ep->msi_mem + aligned_offset);
539
540 dw_pcie_ep_unmap_addr(epc, func_no, 0, ep->msi_mem_phys);
541
542 return 0;
543 }
544 EXPORT_SYMBOL_GPL(dw_pcie_ep_raise_msi_irq);
545
dw_pcie_ep_raise_msix_irq_doorbell(struct dw_pcie_ep * ep,u8 func_no,u16 interrupt_num)546 int dw_pcie_ep_raise_msix_irq_doorbell(struct dw_pcie_ep *ep, u8 func_no,
547 u16 interrupt_num)
548 {
549 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
550 struct dw_pcie_ep_func *ep_func;
551 u32 msg_data;
552
553 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
554 if (!ep_func || !ep_func->msix_cap)
555 return -EINVAL;
556
557 msg_data = (func_no << PCIE_MSIX_DOORBELL_PF_SHIFT) |
558 (interrupt_num - 1);
559
560 dw_pcie_writel_dbi(pci, PCIE_MSIX_DOORBELL, msg_data);
561
562 return 0;
563 }
564
dw_pcie_ep_raise_msix_irq(struct dw_pcie_ep * ep,u8 func_no,u16 interrupt_num)565 int dw_pcie_ep_raise_msix_irq(struct dw_pcie_ep *ep, u8 func_no,
566 u16 interrupt_num)
567 {
568 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
569 struct dw_pcie_ep_func *ep_func;
570 struct pci_epf_msix_tbl *msix_tbl;
571 struct pci_epc *epc = ep->epc;
572 unsigned int func_offset = 0;
573 u32 reg, msg_data, vec_ctrl;
574 unsigned int aligned_offset;
575 u32 tbl_offset;
576 u64 msg_addr;
577 int ret;
578 u8 bir;
579
580 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
581 if (!ep_func || !ep_func->msix_cap)
582 return -EINVAL;
583
584 func_offset = dw_pcie_ep_func_select(ep, func_no);
585
586 reg = ep_func->msix_cap + func_offset + PCI_MSIX_TABLE;
587 tbl_offset = dw_pcie_readl_dbi(pci, reg);
588 bir = (tbl_offset & PCI_MSIX_TABLE_BIR);
589 tbl_offset &= PCI_MSIX_TABLE_OFFSET;
590
591 msix_tbl = ep->epf_bar[bir]->addr + tbl_offset;
592 msg_addr = msix_tbl[(interrupt_num - 1)].msg_addr;
593 msg_data = msix_tbl[(interrupt_num - 1)].msg_data;
594 vec_ctrl = msix_tbl[(interrupt_num - 1)].vector_ctrl;
595
596 if (vec_ctrl & PCI_MSIX_ENTRY_CTRL_MASKBIT) {
597 dev_dbg(pci->dev, "MSI-X entry ctrl set\n");
598 return -EPERM;
599 }
600
601 aligned_offset = msg_addr & (epc->mem->window.page_size - 1);
602 msg_addr = ALIGN_DOWN(msg_addr, epc->mem->window.page_size);
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 dw_pcie *pci = to_dw_pcie_from_ep(ep);
618 struct pci_epc *epc = ep->epc;
619
620 dw_pcie_edma_remove(pci);
621
622 pci_epc_mem_free_addr(epc, ep->msi_mem_phys, ep->msi_mem,
623 epc->mem->window.page_size);
624
625 pci_epc_mem_exit(epc);
626 }
627
dw_pcie_ep_find_ext_capability(struct dw_pcie * pci,int cap)628 static unsigned int dw_pcie_ep_find_ext_capability(struct dw_pcie *pci, int cap)
629 {
630 u32 header;
631 int pos = PCI_CFG_SPACE_SIZE;
632
633 while (pos) {
634 header = dw_pcie_readl_dbi(pci, pos);
635 if (PCI_EXT_CAP_ID(header) == cap)
636 return pos;
637
638 pos = PCI_EXT_CAP_NEXT(header);
639 if (!pos)
640 break;
641 }
642
643 return 0;
644 }
645
dw_pcie_ep_init_complete(struct dw_pcie_ep * ep)646 int dw_pcie_ep_init_complete(struct dw_pcie_ep *ep)
647 {
648 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
649 unsigned int offset, ptm_cap_base;
650 unsigned int nbars;
651 u8 hdr_type;
652 u32 reg;
653 int i;
654
655 hdr_type = dw_pcie_readb_dbi(pci, PCI_HEADER_TYPE) &
656 PCI_HEADER_TYPE_MASK;
657 if (hdr_type != PCI_HEADER_TYPE_NORMAL) {
658 dev_err(pci->dev,
659 "PCIe controller is not set to EP mode (hdr_type:0x%x)!\n",
660 hdr_type);
661 return -EIO;
662 }
663
664 offset = dw_pcie_ep_find_ext_capability(pci, PCI_EXT_CAP_ID_REBAR);
665 ptm_cap_base = dw_pcie_ep_find_ext_capability(pci, PCI_EXT_CAP_ID_PTM);
666
667 dw_pcie_dbi_ro_wr_en(pci);
668
669 if (offset) {
670 reg = dw_pcie_readl_dbi(pci, offset + PCI_REBAR_CTRL);
671 nbars = (reg & PCI_REBAR_CTRL_NBAR_MASK) >>
672 PCI_REBAR_CTRL_NBAR_SHIFT;
673
674 /*
675 * PCIe r6.0, sec 7.8.6.2 require us to support at least one
676 * size in the range from 1 MB to 512 GB. Advertise support
677 * for 1 MB BAR size only.
678 */
679 for (i = 0; i < nbars; i++, offset += PCI_REBAR_CTRL)
680 dw_pcie_writel_dbi(pci, offset + PCI_REBAR_CAP, BIT(4));
681 }
682
683 /*
684 * PTM responder capability can be disabled only after disabling
685 * PTM root capability.
686 */
687 if (ptm_cap_base) {
688 dw_pcie_dbi_ro_wr_en(pci);
689 reg = dw_pcie_readl_dbi(pci, ptm_cap_base + PCI_PTM_CAP);
690 reg &= ~PCI_PTM_CAP_ROOT;
691 dw_pcie_writel_dbi(pci, ptm_cap_base + PCI_PTM_CAP, reg);
692
693 reg = dw_pcie_readl_dbi(pci, ptm_cap_base + PCI_PTM_CAP);
694 reg &= ~(PCI_PTM_CAP_RES | PCI_PTM_GRANULARITY_MASK);
695 dw_pcie_writel_dbi(pci, ptm_cap_base + PCI_PTM_CAP, reg);
696 dw_pcie_dbi_ro_wr_dis(pci);
697 }
698
699 dw_pcie_setup(pci);
700 dw_pcie_dbi_ro_wr_dis(pci);
701
702 return 0;
703 }
704 EXPORT_SYMBOL_GPL(dw_pcie_ep_init_complete);
705
dw_pcie_ep_init(struct dw_pcie_ep * ep)706 int dw_pcie_ep_init(struct dw_pcie_ep *ep)
707 {
708 int ret;
709 void *addr;
710 u8 func_no;
711 struct resource *res;
712 struct pci_epc *epc;
713 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
714 struct device *dev = pci->dev;
715 struct platform_device *pdev = to_platform_device(dev);
716 struct device_node *np = dev->of_node;
717 const struct pci_epc_features *epc_features;
718 struct dw_pcie_ep_func *ep_func;
719
720 INIT_LIST_HEAD(&ep->func_list);
721
722 ret = dw_pcie_get_resources(pci);
723 if (ret)
724 return ret;
725
726 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "addr_space");
727 if (!res)
728 return -EINVAL;
729
730 ep->phys_base = res->start;
731 ep->addr_size = resource_size(res);
732
733 dw_pcie_version_detect(pci);
734
735 dw_pcie_iatu_detect(pci);
736
737 ep->ib_window_map = devm_bitmap_zalloc(dev, pci->num_ib_windows,
738 GFP_KERNEL);
739 if (!ep->ib_window_map)
740 return -ENOMEM;
741
742 ep->ob_window_map = devm_bitmap_zalloc(dev, pci->num_ob_windows,
743 GFP_KERNEL);
744 if (!ep->ob_window_map)
745 return -ENOMEM;
746
747 addr = devm_kcalloc(dev, pci->num_ob_windows, sizeof(phys_addr_t),
748 GFP_KERNEL);
749 if (!addr)
750 return -ENOMEM;
751 ep->outbound_addr = addr;
752
753 epc = devm_pci_epc_create(dev, &epc_ops);
754 if (IS_ERR(epc)) {
755 dev_err(dev, "Failed to create epc device\n");
756 return PTR_ERR(epc);
757 }
758
759 ep->epc = epc;
760 epc_set_drvdata(epc, ep);
761
762 ret = of_property_read_u8(np, "max-functions", &epc->max_functions);
763 if (ret < 0)
764 epc->max_functions = 1;
765
766 for (func_no = 0; func_no < epc->max_functions; func_no++) {
767 ep_func = devm_kzalloc(dev, sizeof(*ep_func), GFP_KERNEL);
768 if (!ep_func)
769 return -ENOMEM;
770
771 ep_func->func_no = func_no;
772 ep_func->msi_cap = dw_pcie_ep_find_capability(ep, func_no,
773 PCI_CAP_ID_MSI);
774 ep_func->msix_cap = dw_pcie_ep_find_capability(ep, func_no,
775 PCI_CAP_ID_MSIX);
776
777 list_add_tail(&ep_func->list, &ep->func_list);
778 }
779
780 if (ep->ops->ep_init)
781 ep->ops->ep_init(ep);
782
783 ret = pci_epc_mem_init(epc, ep->phys_base, ep->addr_size,
784 ep->page_size);
785 if (ret < 0) {
786 dev_err(dev, "Failed to initialize address space\n");
787 return ret;
788 }
789
790 ep->msi_mem = pci_epc_mem_alloc_addr(epc, &ep->msi_mem_phys,
791 epc->mem->window.page_size);
792 if (!ep->msi_mem) {
793 ret = -ENOMEM;
794 dev_err(dev, "Failed to reserve memory for MSI/MSI-X\n");
795 goto err_exit_epc_mem;
796 }
797
798 ret = dw_pcie_edma_detect(pci);
799 if (ret)
800 goto err_free_epc_mem;
801
802 if (ep->ops->get_features) {
803 epc_features = ep->ops->get_features(ep);
804 if (epc_features->core_init_notifier)
805 return 0;
806 }
807
808 ret = dw_pcie_ep_init_complete(ep);
809 if (ret)
810 goto err_remove_edma;
811
812 return 0;
813
814 err_remove_edma:
815 dw_pcie_edma_remove(pci);
816
817 err_free_epc_mem:
818 pci_epc_mem_free_addr(epc, ep->msi_mem_phys, ep->msi_mem,
819 epc->mem->window.page_size);
820
821 err_exit_epc_mem:
822 pci_epc_mem_exit(epc);
823
824 return ret;
825 }
826 EXPORT_SYMBOL_GPL(dw_pcie_ep_init);
827