forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c 
 kernel/drivers/pci/controller/dwc/pcie-designware-ep.c
....@@ -1,5 +1,5 @@
11 // SPDX-License-Identifier: GPL-2.0
2
-/**
2
+/*
33  * Synopsys DesignWare PCIe Endpoint controller driver
44  *
55  * Copyright (C) 2017 Texas Instruments
....@@ -12,19 +12,57 @@
1212 #include <linux/pci-epc.h>
1313 #include <linux/pci-epf.h>
1414 
15
+#include "../../pci.h"
16
+
1517 void dw_pcie_ep_linkup(struct dw_pcie_ep *ep)
1618 {
1719 	struct pci_epc *epc = ep->epc;
1820 
1921 	pci_epc_linkup(epc);
2022 }
23
+EXPORT_SYMBOL_GPL(dw_pcie_ep_linkup);
2124 
22
-static void __dw_pcie_ep_reset_bar(struct dw_pcie *pci, enum pci_barno bar,
23
-				   int flags)
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 *
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
+
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
+
56
+static void __dw_pcie_ep_reset_bar(struct dw_pcie *pci, u8 func_no,
57
+				   enum pci_barno bar, int flags)
2458 {
2559 	u32 reg;
60
+	unsigned int func_offset = 0;
61
+	struct dw_pcie_ep *ep = &pci->ep;
2662 
27
-	reg = PCI_BASE_ADDRESS_0 + (4 * bar);
63
+	func_offset = dw_pcie_ep_func_select(ep, func_no);
64
+
65
+	reg = func_offset + PCI_BASE_ADDRESS_0 + (4 * bar);
2866 	dw_pcie_dbi_ro_wr_en(pci);
2967 	dw_pcie_writel_dbi2(pci, reg, 0x0);
3068 	dw_pcie_writel_dbi(pci, reg, 0x0);
....@@ -37,19 +75,28 @@
3775 
3876 void dw_pcie_ep_reset_bar(struct dw_pcie *pci, enum pci_barno bar)
3977 {
40
-	__dw_pcie_ep_reset_bar(pci, bar, 0);
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);
4184 }
4285 
43
-static u8 __dw_pcie_ep_find_next_cap(struct dw_pcie *pci, u8 cap_ptr,
44
-			      u8 cap)
86
+static u8 __dw_pcie_ep_find_next_cap(struct dw_pcie_ep *ep, u8 func_no,
87
+		u8 cap_ptr, u8 cap)
4588 {
89
+	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
90
+	unsigned int func_offset = 0;
4691 	u8 cap_id, next_cap_ptr;
4792 	u16 reg;
4893 
4994 	if (!cap_ptr)
5095 		return 0;
5196 
52
-	reg = dw_pcie_readw_dbi(pci, cap_ptr);
97
+	func_offset = dw_pcie_ep_func_select(ep, func_no);
98
+
99
+	reg = dw_pcie_readw_dbi(pci, func_offset + cap_ptr);
53100 	cap_id = (reg & 0x00ff);
54101 
55102 	if (cap_id > PCI_CAP_ID_MAX)
....@@ -59,47 +106,55 @@
59106 		return cap_ptr;
60107 
61108 	next_cap_ptr = (reg & 0xff00) >> 8;
62
-	return __dw_pcie_ep_find_next_cap(pci, next_cap_ptr, cap);
109
+	return __dw_pcie_ep_find_next_cap(ep, func_no, next_cap_ptr, cap);
63110 }
64111 
65
-static u8 dw_pcie_ep_find_capability(struct dw_pcie *pci, u8 cap)
112
+static u8 dw_pcie_ep_find_capability(struct dw_pcie_ep *ep, u8 func_no, u8 cap)
66113 {
114
+	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
115
+	unsigned int func_offset = 0;
67116 	u8 next_cap_ptr;
68117 	u16 reg;
69118 
70
-	reg = dw_pcie_readw_dbi(pci, PCI_CAPABILITY_LIST);
119
+	func_offset = dw_pcie_ep_func_select(ep, func_no);
120
+
121
+	reg = dw_pcie_readw_dbi(pci, func_offset + PCI_CAPABILITY_LIST);
71122 	next_cap_ptr = (reg & 0x00ff);
72123 
73
-	return __dw_pcie_ep_find_next_cap(pci, next_cap_ptr, cap);
124
+	return __dw_pcie_ep_find_next_cap(ep, func_no, next_cap_ptr, cap);
74125 }
126
+EXPORT_SYMBOL_GPL(dw_pcie_ep_reset_bar);
75127 
76128 static int dw_pcie_ep_write_header(struct pci_epc *epc, u8 func_no,
77129 				   struct pci_epf_header *hdr)
78130 {
79131 	struct dw_pcie_ep *ep = epc_get_drvdata(epc);
80132 	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);
81136 
82137 	dw_pcie_dbi_ro_wr_en(pci);
83
-	dw_pcie_writew_dbi(pci, PCI_VENDOR_ID, hdr->vendorid);
84
-	dw_pcie_writew_dbi(pci, PCI_DEVICE_ID, hdr->deviceid);
85
-	dw_pcie_writeb_dbi(pci, PCI_REVISION_ID, hdr->revid);
86
-	dw_pcie_writeb_dbi(pci, PCI_CLASS_PROG, hdr->progif_code);
87
-	dw_pcie_writew_dbi(pci, PCI_CLASS_DEVICE,
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,
88143 			   hdr->subclass_code | hdr->baseclass_code << 8);
89
-	dw_pcie_writeb_dbi(pci, PCI_CACHE_LINE_SIZE,
144
+	dw_pcie_writeb_dbi(pci, func_offset + PCI_CACHE_LINE_SIZE,
90145 			   hdr->cache_line_size);
91
-	dw_pcie_writew_dbi(pci, PCI_SUBSYSTEM_VENDOR_ID,
146
+	dw_pcie_writew_dbi(pci, func_offset + PCI_SUBSYSTEM_VENDOR_ID,
92147 			   hdr->subsys_vendor_id);
93
-	dw_pcie_writew_dbi(pci, PCI_SUBSYSTEM_ID, hdr->subsys_id);
94
-	dw_pcie_writeb_dbi(pci, PCI_INTERRUPT_PIN,
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,
95150 			   hdr->interrupt_pin);
96151 	dw_pcie_dbi_ro_wr_dis(pci);
97152 
98153 	return 0;
99154 }
100155 
101
-static int dw_pcie_ep_inbound_atu(struct dw_pcie_ep *ep, enum pci_barno bar,
102
-				  dma_addr_t cpu_addr,
156
+static int dw_pcie_ep_inbound_atu(struct dw_pcie_ep *ep, u8 func_no,
157
+				  enum pci_barno bar, dma_addr_t cpu_addr,
103158 				  enum dw_pcie_as_type as_type)
104159 {
105160 	int ret;
....@@ -112,7 +167,7 @@
112167 		return -EINVAL;
113168 	}
114169 
115
-	ret = dw_pcie_prog_inbound_atu(pci, free_win, bar, cpu_addr,
170
+	ret = dw_pcie_prog_inbound_atu(pci, func_no, free_win, bar, cpu_addr,
116171 				       as_type);
117172 	if (ret < 0) {
118173 		dev_err(pci->dev, "Failed to program IB window\n");
....@@ -125,7 +180,8 @@
125180 	return 0;
126181 }
127182 
128
-static int dw_pcie_ep_outbound_atu(struct dw_pcie_ep *ep, phys_addr_t phys_addr,
183
+static int dw_pcie_ep_outbound_atu(struct dw_pcie_ep *ep, u8 func_no,
184
+				   phys_addr_t phys_addr,
129185 				   u64 pci_addr, size_t size)
130186 {
131187 	u32 free_win;
....@@ -137,8 +193,8 @@
137193 		return -EINVAL;
138194 	}
139195 
140
-	dw_pcie_prog_outbound_atu(pci, free_win, PCIE_ATU_TYPE_MEM,
141
-				  phys_addr, pci_addr, size);
196
+	dw_pcie_prog_ep_outbound_atu(pci, func_no, free_win, PCIE_ATU_TYPE_MEM,
197
+				     phys_addr, pci_addr, size);
142198 
143199 	set_bit(free_win, ep->ob_window_map);
144200 	ep->outbound_addr[free_win] = phys_addr;
....@@ -154,10 +210,11 @@
154210 	enum pci_barno bar = epf_bar->barno;
155211 	u32 atu_index = ep->bar_to_atu[bar];
156212 
157
-	__dw_pcie_ep_reset_bar(pci, bar, epf_bar->flags);
213
+	__dw_pcie_ep_reset_bar(pci, func_no, bar, epf_bar->flags);
158214 
159215 	dw_pcie_disable_atu(pci, atu_index, DW_PCIE_REGION_INBOUND);
160216 	clear_bit(atu_index, ep->ib_window_map);
217
+	ep->epf_bar[bar] = NULL;
161218 }
162219 
163220 static int dw_pcie_ep_set_bar(struct pci_epc *epc, u8 func_no,
....@@ -170,14 +227,20 @@
170227 	size_t size = epf_bar->size;
171228 	int flags = epf_bar->flags;
172229 	enum dw_pcie_as_type as_type;
173
-	u32 reg = PCI_BASE_ADDRESS_0 + (4 * bar);
230
+	u32 reg;
231
+	unsigned int func_offset = 0;
232
+
233
+	func_offset = dw_pcie_ep_func_select(ep, func_no);
234
+
235
+	reg = PCI_BASE_ADDRESS_0 + (4 * bar) + func_offset;
174236 
175237 	if (!(flags & PCI_BASE_ADDRESS_SPACE))
176238 		as_type = DW_PCIE_AS_MEM;
177239 	else
178240 		as_type = DW_PCIE_AS_IO;
179241 
180
-	ret = dw_pcie_ep_inbound_atu(ep, bar, epf_bar->phys_addr, as_type);
242
+	ret = dw_pcie_ep_inbound_atu(ep, func_no, bar,
243
+				     epf_bar->phys_addr, as_type);
181244 	if (ret)
182245 		return ret;
183246 
....@@ -191,6 +254,7 @@
191254 		dw_pcie_writel_dbi(pci, reg + 4, 0);
192255 	}
193256 
257
+	ep->epf_bar[bar] = epf_bar;
194258 	dw_pcie_dbi_ro_wr_dis(pci);
195259 
196260 	return 0;
....@@ -235,7 +299,7 @@
235299 	struct dw_pcie_ep *ep = epc_get_drvdata(epc);
236300 	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
237301 
238
-	ret = dw_pcie_ep_outbound_atu(ep, addr, pci_addr, size);
302
+	ret = dw_pcie_ep_outbound_atu(ep, func_no, addr, pci_addr, size);
239303 	if (ret) {
240304 		dev_err(pci->dev, "Failed to enable address\n");
241305 		return ret;
....@@ -249,11 +313,16 @@
249313 	struct dw_pcie_ep *ep = epc_get_drvdata(epc);
250314 	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
251315 	u32 val, reg;
316
+	unsigned int func_offset = 0;
317
+	struct dw_pcie_ep_func *ep_func;
252318 
253
-	if (!ep->msi_cap)
319
+	ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
320
+	if (!ep_func || !ep_func->msi_cap)
254321 		return -EINVAL;
255322 
256
-	reg = ep->msi_cap + PCI_MSI_FLAGS;
323
+	func_offset = dw_pcie_ep_func_select(ep, func_no);
324
+
325
+	reg = ep_func->msi_cap + func_offset + PCI_MSI_FLAGS;
257326 	val = dw_pcie_readw_dbi(pci, reg);
258327 	if (!(val & PCI_MSI_FLAGS_ENABLE))
259328 		return -EINVAL;
....@@ -268,11 +337,16 @@
268337 	struct dw_pcie_ep *ep = epc_get_drvdata(epc);
269338 	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
270339 	u32 val, reg;
340
+	unsigned int func_offset = 0;
341
+	struct dw_pcie_ep_func *ep_func;
271342 
272
-	if (!ep->msi_cap)
343
+	ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
344
+	if (!ep_func || !ep_func->msi_cap)
273345 		return -EINVAL;
274346 
275
-	reg = ep->msi_cap + PCI_MSI_FLAGS;
347
+	func_offset = dw_pcie_ep_func_select(ep, func_no);
348
+
349
+	reg = ep_func->msi_cap + func_offset + PCI_MSI_FLAGS;
276350 	val = dw_pcie_readw_dbi(pci, reg);
277351 	val &= ~PCI_MSI_FLAGS_QMASK;
278352 	val |= (interrupts << 1) & PCI_MSI_FLAGS_QMASK;
....@@ -288,11 +362,16 @@
288362 	struct dw_pcie_ep *ep = epc_get_drvdata(epc);
289363 	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
290364 	u32 val, reg;
365
+	unsigned int func_offset = 0;
366
+	struct dw_pcie_ep_func *ep_func;
291367 
292
-	if (!ep->msix_cap)
368
+	ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
369
+	if (!ep_func || !ep_func->msix_cap)
293370 		return -EINVAL;
294371 
295
-	reg = ep->msix_cap + PCI_MSIX_FLAGS;
372
+	func_offset = dw_pcie_ep_func_select(ep, func_no);
373
+
374
+	reg = ep_func->msix_cap + func_offset + PCI_MSIX_FLAGS;
296375 	val = dw_pcie_readw_dbi(pci, reg);
297376 	if (!(val & PCI_MSIX_FLAGS_ENABLE))
298377 		return -EINVAL;
....@@ -302,21 +381,37 @@
302381 	return val;
303382 }
304383 
305
-static int dw_pcie_ep_set_msix(struct pci_epc *epc, u8 func_no, u16 interrupts)
384
+static int dw_pcie_ep_set_msix(struct pci_epc *epc, u8 func_no, u16 interrupts,
385
+			       enum pci_barno bir, u32 offset)
306386 {
307387 	struct dw_pcie_ep *ep = epc_get_drvdata(epc);
308388 	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
309389 	u32 val, reg;
390
+	unsigned int func_offset = 0;
391
+	struct dw_pcie_ep_func *ep_func;
310392 
311
-	if (!ep->msix_cap)
393
+	ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
394
+	if (!ep_func || !ep_func->msix_cap)
312395 		return -EINVAL;
313396 
314
-	reg = ep->msix_cap + PCI_MSIX_FLAGS;
397
+	dw_pcie_dbi_ro_wr_en(pci);
398
+
399
+	func_offset = dw_pcie_ep_func_select(ep, func_no);
400
+
401
+	reg = ep_func->msix_cap + func_offset + PCI_MSIX_FLAGS;
315402 	val = dw_pcie_readw_dbi(pci, reg);
316403 	val &= ~PCI_MSIX_FLAGS_QSIZE;
317404 	val |= interrupts;
318
-	dw_pcie_dbi_ro_wr_en(pci);
319405 	dw_pcie_writew_dbi(pci, reg, val);
406
+
407
+	reg = ep_func->msix_cap + func_offset + PCI_MSIX_TABLE;
408
+	val = offset | bir;
409
+	dw_pcie_writel_dbi(pci, reg, val);
410
+
411
+	reg = ep_func->msix_cap + func_offset + PCI_MSIX_PBA;
412
+	val = (offset + (interrupts * PCI_MSIX_ENTRY_SIZE)) | bir;
413
+	dw_pcie_writel_dbi(pci, reg, val);
414
+
320415 	dw_pcie_dbi_ro_wr_dis(pci);
321416 
322417 	return 0;
....@@ -355,6 +450,17 @@
355450 	return pci->ops->start_link(pci);
356451 }
357452 
453
+static const struct pci_epc_features*
454
+dw_pcie_ep_get_features(struct pci_epc *epc, u8 func_no)
455
+{
456
+	struct dw_pcie_ep *ep = epc_get_drvdata(epc);
457
+
458
+	if (!ep->ops->get_features)
459
+		return NULL;
460
+
461
+	return ep->ops->get_features(ep);
462
+}
463
+
358464 static const struct pci_epc_ops epc_ops = {
359465 	.write_header		= dw_pcie_ep_write_header,
360466 	.set_bar		= dw_pcie_ep_set_bar,
....@@ -368,6 +474,7 @@
368474 	.raise_irq		= dw_pcie_ep_raise_irq,
369475 	.start			= dw_pcie_ep_start,
370476 	.stop			= dw_pcie_ep_stop,
477
+	.get_features		= dw_pcie_ep_get_features,
371478 };
372479 
373480 int dw_pcie_ep_raise_legacy_irq(struct dw_pcie_ep *ep, u8 func_no)
....@@ -379,43 +486,49 @@
379486 
380487 	return -EINVAL;
381488 }
489
+EXPORT_SYMBOL_GPL(dw_pcie_ep_raise_legacy_irq);
382490 
383491 int dw_pcie_ep_raise_msi_irq(struct dw_pcie_ep *ep, u8 func_no,
384492 			     u8 interrupt_num)
385493 {
386494 	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
495
+	struct dw_pcie_ep_func *ep_func;
387496 	struct pci_epc *epc = ep->epc;
388497 	unsigned int aligned_offset;
498
+	unsigned int func_offset = 0;
389499 	u16 msg_ctrl, msg_data;
390500 	u32 msg_addr_lower, msg_addr_upper, reg;
391501 	u64 msg_addr;
392502 	bool has_upper;
393503 	int ret;
394504 
395
-	if (!ep->msi_cap)
505
+	ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
506
+	if (!ep_func || !ep_func->msi_cap)
396507 		return -EINVAL;
397508 
509
+	func_offset = dw_pcie_ep_func_select(ep, func_no);
510
+
398511 	/* Raise MSI per the PCI Local Bus Specification Revision 3.0, 6.8.1. */
399
-	reg = ep->msi_cap + PCI_MSI_FLAGS;
512
+	reg = ep_func->msi_cap + func_offset + PCI_MSI_FLAGS;
400513 	msg_ctrl = dw_pcie_readw_dbi(pci, reg);
401514 	has_upper = !!(msg_ctrl & PCI_MSI_FLAGS_64BIT);
402
-	reg = ep->msi_cap + PCI_MSI_ADDRESS_LO;
515
+	reg = ep_func->msi_cap + func_offset + PCI_MSI_ADDRESS_LO;
403516 	msg_addr_lower = dw_pcie_readl_dbi(pci, reg);
404517 	if (has_upper) {
405
-		reg = ep->msi_cap + PCI_MSI_ADDRESS_HI;
518
+		reg = ep_func->msi_cap + func_offset + PCI_MSI_ADDRESS_HI;
406519 		msg_addr_upper = dw_pcie_readl_dbi(pci, reg);
407
-		reg = ep->msi_cap + PCI_MSI_DATA_64;
520
+		reg = ep_func->msi_cap + func_offset + PCI_MSI_DATA_64;
408521 		msg_data = dw_pcie_readw_dbi(pci, reg);
409522 	} else {
410523 		msg_addr_upper = 0;
411
-		reg = ep->msi_cap + PCI_MSI_DATA_32;
524
+		reg = ep_func->msi_cap + func_offset + PCI_MSI_DATA_32;
412525 		msg_data = dw_pcie_readw_dbi(pci, reg);
413526 	}
414
-	aligned_offset = msg_addr_lower & (epc->mem->page_size - 1);
527
+	aligned_offset = msg_addr_lower & (epc->mem->window.page_size - 1);
415528 	msg_addr = ((u64)msg_addr_upper) << 32 |
416529 			(msg_addr_lower & ~aligned_offset);
417530 	ret = dw_pcie_ep_map_addr(epc, func_no, ep->msi_mem_phys, msg_addr,
418
-				  epc->mem->page_size);
531
+				  epc->mem->window.page_size);
419532 	if (ret)
420533 		return ret;
421534 
....@@ -425,82 +538,156 @@
425538 
426539 	return 0;
427540 }
541
+EXPORT_SYMBOL_GPL(dw_pcie_ep_raise_msi_irq);
428542 
429
-int dw_pcie_ep_raise_msix_irq(struct dw_pcie_ep *ep, u8 func_no,
430
-			     u16 interrupt_num)
543
+int dw_pcie_ep_raise_msix_irq_doorbell(struct dw_pcie_ep *ep, u8 func_no,
544
+				       u16 interrupt_num)
431545 {
432546 	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
433
-	struct pci_epc *epc = ep->epc;
434
-	u16 tbl_offset, bir;
435
-	u32 bar_addr_upper, bar_addr_lower;
436
-	u32 msg_addr_upper, msg_addr_lower;
437
-	u32 reg, msg_data, vec_ctrl;
438
-	u64 tbl_addr, msg_addr, reg_u64;
439
-	void __iomem *msix_tbl;
440
-	int ret;
547
+	struct dw_pcie_ep_func *ep_func;
548
+	u32 msg_data;
441549 
442
-	reg = ep->msix_cap + PCI_MSIX_TABLE;
550
+	ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
551
+	if (!ep_func || !ep_func->msix_cap)
552
+		return -EINVAL;
553
+
554
+	msg_data = (func_no << PCIE_MSIX_DOORBELL_PF_SHIFT) |
555
+		   (interrupt_num - 1);
556
+
557
+	dw_pcie_writel_dbi(pci, PCIE_MSIX_DOORBELL, msg_data);
558
+
559
+	return 0;
560
+}
561
+
562
+int dw_pcie_ep_raise_msix_irq(struct dw_pcie_ep *ep, u8 func_no,
563
+			      u16 interrupt_num)
564
+{
565
+	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
566
+	struct dw_pcie_ep_func *ep_func;
567
+	struct pci_epf_msix_tbl *msix_tbl;
568
+	struct pci_epc *epc = ep->epc;
569
+	unsigned int func_offset = 0;
570
+	u32 reg, msg_data, vec_ctrl;
571
+	unsigned int aligned_offset;
572
+	u32 tbl_offset;
573
+	u64 msg_addr;
574
+	int ret;
575
+	u8 bir;
576
+
577
+	ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
578
+	if (!ep_func || !ep_func->msix_cap)
579
+		return -EINVAL;
580
+
581
+	func_offset = dw_pcie_ep_func_select(ep, func_no);
582
+
583
+	reg = ep_func->msix_cap + func_offset + PCI_MSIX_TABLE;
443584 	tbl_offset = dw_pcie_readl_dbi(pci, reg);
444585 	bir = (tbl_offset & PCI_MSIX_TABLE_BIR);
445586 	tbl_offset &= PCI_MSIX_TABLE_OFFSET;
446587 
447
-	reg = PCI_BASE_ADDRESS_0 + (4 * bir);
448
-	bar_addr_upper = 0;
449
-	bar_addr_lower = dw_pcie_readl_dbi(pci, reg);
450
-	reg_u64 = (bar_addr_lower & PCI_BASE_ADDRESS_MEM_TYPE_MASK);
451
-	if (reg_u64 == PCI_BASE_ADDRESS_MEM_TYPE_64)
452
-		bar_addr_upper = dw_pcie_readl_dbi(pci, reg + 4);
588
+	msix_tbl = ep->epf_bar[bir]->addr + tbl_offset;
589
+	msg_addr = msix_tbl[(interrupt_num - 1)].msg_addr;
590
+	msg_data = msix_tbl[(interrupt_num - 1)].msg_data;
591
+	vec_ctrl = msix_tbl[(interrupt_num - 1)].vector_ctrl;
453592 
454
-	tbl_addr = ((u64) bar_addr_upper) << 32 | bar_addr_lower;
455
-	tbl_addr += (tbl_offset + ((interrupt_num - 1) * PCI_MSIX_ENTRY_SIZE));
456
-	tbl_addr &= PCI_BASE_ADDRESS_MEM_MASK;
457
-
458
-	msix_tbl = ioremap_nocache(ep->phys_base + tbl_addr,
459
-				   PCI_MSIX_ENTRY_SIZE);
460
-	if (!msix_tbl)
461
-		return -EINVAL;
462
-
463
-	msg_addr_lower = readl(msix_tbl + PCI_MSIX_ENTRY_LOWER_ADDR);
464
-	msg_addr_upper = readl(msix_tbl + PCI_MSIX_ENTRY_UPPER_ADDR);
465
-	msg_addr = ((u64) msg_addr_upper) << 32 | msg_addr_lower;
466
-	msg_data = readl(msix_tbl + PCI_MSIX_ENTRY_DATA);
467
-	vec_ctrl = readl(msix_tbl + PCI_MSIX_ENTRY_VECTOR_CTRL);
468
-
469
-	iounmap(msix_tbl);
470
-
471
-	if (vec_ctrl & PCI_MSIX_ENTRY_CTRL_MASKBIT)
593
+	if (vec_ctrl & PCI_MSIX_ENTRY_CTRL_MASKBIT) {
594
+		dev_dbg(pci->dev, "MSI-X entry ctrl set\n");
472595 		return -EPERM;
596
+	}
473597 
474
-	ret = dw_pcie_ep_map_addr(epc, func_no, ep->msi_mem_phys, msg_addr,
475
-				  epc->mem->page_size);
598
+	aligned_offset = msg_addr & (epc->mem->window.page_size - 1);
599
+	ret = dw_pcie_ep_map_addr(epc, func_no, ep->msi_mem_phys,  msg_addr,
600
+				  epc->mem->window.page_size);
476601 	if (ret)
477602 		return ret;
478603 
479
-	writel(msg_data, ep->msi_mem);
604
+	writel(msg_data, ep->msi_mem + aligned_offset);
480605 
481606 	dw_pcie_ep_unmap_addr(epc, func_no, ep->msi_mem_phys);
482607 
483608 	return 0;
484609 }
610
+EXPORT_SYMBOL_GPL(dw_pcie_ep_raise_msix_irq);
485611 
486612 void dw_pcie_ep_exit(struct dw_pcie_ep *ep)
487613 {
488614 	struct pci_epc *epc = ep->epc;
489615 
490616 	pci_epc_mem_free_addr(epc, ep->msi_mem_phys, ep->msi_mem,
491
-			      epc->mem->page_size);
617
+			      epc->mem->window.page_size);
492618 
493619 	pci_epc_mem_exit(epc);
494620 }
621
+
622
+static unsigned int dw_pcie_ep_find_ext_capability(struct dw_pcie *pci, int cap)
623
+{
624
+	u32 header;
625
+	int pos = PCI_CFG_SPACE_SIZE;
626
+
627
+	while (pos) {
628
+		header = dw_pcie_readl_dbi(pci, pos);
629
+		if (PCI_EXT_CAP_ID(header) == cap)
630
+			return pos;
631
+
632
+		pos = PCI_EXT_CAP_NEXT(header);
633
+		if (!pos)
634
+			break;
635
+	}
636
+
637
+	return 0;
638
+}
639
+
640
+int dw_pcie_ep_init_complete(struct dw_pcie_ep *ep)
641
+{
642
+	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
643
+	unsigned int offset;
644
+	unsigned int nbars;
645
+	u8 hdr_type;
646
+	u32 reg;
647
+	int i;
648
+
649
+	hdr_type = dw_pcie_readb_dbi(pci, PCI_HEADER_TYPE) &
650
+		   PCI_HEADER_TYPE_MASK;
651
+	if (hdr_type != PCI_HEADER_TYPE_NORMAL) {
652
+		dev_err(pci->dev,
653
+			"PCIe controller is not set to EP mode (hdr_type:0x%x)!\n",
654
+			hdr_type);
655
+		return -EIO;
656
+	}
657
+
658
+	offset = dw_pcie_ep_find_ext_capability(pci, PCI_EXT_CAP_ID_REBAR);
659
+
660
+	dw_pcie_dbi_ro_wr_en(pci);
661
+
662
+	if (offset) {
663
+		reg = dw_pcie_readl_dbi(pci, offset + PCI_REBAR_CTRL);
664
+		nbars = (reg & PCI_REBAR_CTRL_NBAR_MASK) >>
665
+			PCI_REBAR_CTRL_NBAR_SHIFT;
666
+
667
+		for (i = 0; i < nbars; i++, offset += PCI_REBAR_CTRL)
668
+			dw_pcie_writel_dbi(pci, offset + PCI_REBAR_CAP, 0x0);
669
+	}
670
+
671
+	dw_pcie_setup(pci);
672
+	dw_pcie_dbi_ro_wr_dis(pci);
673
+
674
+	return 0;
675
+}
676
+EXPORT_SYMBOL_GPL(dw_pcie_ep_init_complete);
495677 
496678 int dw_pcie_ep_init(struct dw_pcie_ep *ep)
497679 {
498680 	int ret;
499681 	void *addr;
682
+	u8 func_no;
500683 	struct pci_epc *epc;
501684 	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
502685 	struct device *dev = pci->dev;
503686 	struct device_node *np = dev->of_node;
687
+	const struct pci_epc_features *epc_features;
688
+	struct dw_pcie_ep_func *ep_func;
689
+
690
+	INIT_LIST_HEAD(&ep->func_list);
504691 
505692 	if (!pci->dbi_base || !pci->dbi_base2) {
506693 		dev_err(dev, "dbi_base/dbi_base2 is not populated\n");
....@@ -547,6 +734,9 @@
547734 		return -ENOMEM;
548735 	ep->outbound_addr = addr;
549736 
737
+	if (pci->link_gen < 1)
738
+		pci->link_gen = of_pci_get_max_link_speed(np);
739
+
550740 	epc = devm_pci_epc_create(dev, &epc_ops);
551741 	if (IS_ERR(epc)) {
552742 		dev_err(dev, "Failed to create epc device\n");
....@@ -556,31 +746,61 @@
556746 	ep->epc = epc;
557747 	epc_set_drvdata(epc, ep);
558748 
559
-	if (ep->ops->ep_init)
560
-		ep->ops->ep_init(ep);
561
-
562749 	ret = of_property_read_u8(np, "max-functions", &epc->max_functions);
563750 	if (ret < 0)
564751 		epc->max_functions = 1;
565752 
566
-	ret = __pci_epc_mem_init(epc, ep->phys_base, ep->addr_size,
567
-				 ep->page_size);
753
+	for (func_no = 0; func_no < epc->max_functions; func_no++) {
754
+		ep_func = devm_kzalloc(dev, sizeof(*ep_func), GFP_KERNEL);
755
+		if (!ep_func)
756
+			return -ENOMEM;
757
+
758
+		ep_func->func_no = func_no;
759
+		ep_func->msi_cap = dw_pcie_ep_find_capability(ep, func_no,
760
+							      PCI_CAP_ID_MSI);
761
+		ep_func->msix_cap = dw_pcie_ep_find_capability(ep, func_no,
762
+							       PCI_CAP_ID_MSIX);
763
+
764
+		list_add_tail(&ep_func->list, &ep->func_list);
765
+	}
766
+
767
+	if (ep->ops->ep_init)
768
+		ep->ops->ep_init(ep);
769
+
770
+	ret = pci_epc_mem_init(epc, ep->phys_base, ep->addr_size,
771
+			       ep->page_size);
568772 	if (ret < 0) {
569773 		dev_err(dev, "Failed to initialize address space\n");
570774 		return ret;
571775 	}
572776 
573777 	ep->msi_mem = pci_epc_mem_alloc_addr(epc, &ep->msi_mem_phys,
574
-					     epc->mem->page_size);
778
+					     epc->mem->window.page_size);
575779 	if (!ep->msi_mem) {
780
+		ret = -ENOMEM;
576781 		dev_err(dev, "Failed to reserve memory for MSI/MSI-X\n");
577
-		return -ENOMEM;
782
+		goto err_exit_epc_mem;
578783 	}
579
-	ep->msi_cap = dw_pcie_ep_find_capability(pci, PCI_CAP_ID_MSI);
580784 
581
-	ep->msix_cap = dw_pcie_ep_find_capability(pci, PCI_CAP_ID_MSIX);
785
+	if (ep->ops->get_features) {
786
+		epc_features = ep->ops->get_features(ep);
787
+		if (epc_features->core_init_notifier)
788
+			return 0;
789
+	}
582790 
583
-	dw_pcie_setup(pci);
791
+	ret = dw_pcie_ep_init_complete(ep);
792
+	if (ret)
793
+		goto err_free_epc_mem;
584794 
585795 	return 0;
796
+
797
+err_free_epc_mem:
798
+	pci_epc_mem_free_addr(epc, ep->msi_mem_phys, ep->msi_mem,
799
+			      epc->mem->window.page_size);
800
+
801
+err_exit_epc_mem:
802
+	pci_epc_mem_exit(epc);
803
+
804
+	return ret;
586805 }
806
+EXPORT_SYMBOL_GPL(dw_pcie_ep_init);