1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Synopsys DesignWare PCIe host controller driver
4  *
5  * Copyright (C) 2013 Samsung Electronics Co., Ltd.
6  *		http://www.samsung.com
7  *
8  * Author: Jingoo Han <jg1.han@samsung.com>
9  */
10 
11 #include <linux/delay.h>
12 #include <linux/of.h>
13 #include <linux/types.h>
14 
15 #include "pcie-designware.h"
16 
17 /* PCIe Port Logic registers */
18 #define PLR_OFFSET			0x700
19 #define PCIE_PHY_DEBUG_R1		(PLR_OFFSET + 0x2c)
20 #define PCIE_PHY_DEBUG_R1_LINK_UP	(0x1 << 4)
21 #define PCIE_PHY_DEBUG_R1_LINK_IN_TRAINING	(0x1 << 29)
22 
23 int dw_pcie_read(void __iomem *addr, int size, u32 *val)
24 {
25 	if ((uintptr_t)addr & (size - 1)) {
26 		*val = 0;
27 		return PCIBIOS_BAD_REGISTER_NUMBER;
28 	}
29 
30 	if (size == 4) {
31 		*val = readl(addr);
32 	} else if (size == 2) {
33 		*val = readw(addr);
34 	} else if (size == 1) {
35 		*val = readb(addr);
36 	} else {
37 		*val = 0;
38 		return PCIBIOS_BAD_REGISTER_NUMBER;
39 	}
40 
41 	return PCIBIOS_SUCCESSFUL;
42 }
43 
44 int dw_pcie_write(void __iomem *addr, int size, u32 val)
45 {
46 	if ((uintptr_t)addr & (size - 1))
47 		return PCIBIOS_BAD_REGISTER_NUMBER;
48 
49 	if (size == 4)
50 		writel(val, addr);
51 	else if (size == 2)
52 		writew(val, addr);
53 	else if (size == 1)
54 		writeb(val, addr);
55 	else
56 		return PCIBIOS_BAD_REGISTER_NUMBER;
57 
58 	return PCIBIOS_SUCCESSFUL;
59 }
60 
61 u32 __dw_pcie_read_dbi(struct dw_pcie *pci, void __iomem *base, u32 reg,
62 		       size_t size)
63 {
64 	int ret;
65 	u32 val;
66 
67 	if (pci->ops->read_dbi)
68 		return pci->ops->read_dbi(pci, base, reg, size);
69 
70 	ret = dw_pcie_read(base + reg, size, &val);
71 	if (ret)
72 		dev_err(pci->dev, "Read DBI address failed\n");
73 
74 	return val;
75 }
76 
77 void __dw_pcie_write_dbi(struct dw_pcie *pci, void __iomem *base, u32 reg,
78 			 size_t size, u32 val)
79 {
80 	int ret;
81 
82 	if (pci->ops->write_dbi) {
83 		pci->ops->write_dbi(pci, base, reg, size, val);
84 		return;
85 	}
86 
87 	ret = dw_pcie_write(base + reg, size, val);
88 	if (ret)
89 		dev_err(pci->dev, "Write DBI address failed\n");
90 }
91 
92 static u32 dw_pcie_readl_ob_unroll(struct dw_pcie *pci, u32 index, u32 reg)
93 {
94 	u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index);
95 
96 	return dw_pcie_readl_dbi(pci, offset + reg);
97 }
98 
99 static void dw_pcie_writel_ob_unroll(struct dw_pcie *pci, u32 index, u32 reg,
100 				     u32 val)
101 {
102 	u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index);
103 
104 	dw_pcie_writel_dbi(pci, offset + reg, val);
105 }
106 
107 static void dw_pcie_prog_outbound_atu_unroll(struct dw_pcie *pci, int index,
108 					     int type, u64 cpu_addr,
109 					     u64 pci_addr, u32 size)
110 {
111 	u32 retries, val;
112 
113 	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_LOWER_BASE,
114 				 lower_32_bits(cpu_addr));
115 	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_UPPER_BASE,
116 				 upper_32_bits(cpu_addr));
117 	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_LIMIT,
118 				 lower_32_bits(cpu_addr + size - 1));
119 	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_LOWER_TARGET,
120 				 lower_32_bits(pci_addr));
121 	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_UPPER_TARGET,
122 				 upper_32_bits(pci_addr));
123 	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL1,
124 				 type);
125 	dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL2,
126 				 PCIE_ATU_ENABLE);
127 
128 	/*
129 	 * Make sure ATU enable takes effect before any subsequent config
130 	 * and I/O accesses.
131 	 */
132 	for (retries = 0; retries < LINK_WAIT_MAX_IATU_RETRIES; retries++) {
133 		val = dw_pcie_readl_ob_unroll(pci, index,
134 					      PCIE_ATU_UNR_REGION_CTRL2);
135 		if (val & PCIE_ATU_ENABLE)
136 			return;
137 
138 		usleep_range(LINK_WAIT_IATU_MIN, LINK_WAIT_IATU_MAX);
139 	}
140 	dev_err(pci->dev, "Outbound iATU is not being enabled\n");
141 }
142 
143 void dw_pcie_prog_outbound_atu(struct dw_pcie *pci, int index, int type,
144 			       u64 cpu_addr, u64 pci_addr, u32 size)
145 {
146 	u32 retries, val;
147 
148 	if (pci->ops->cpu_addr_fixup)
149 		cpu_addr = pci->ops->cpu_addr_fixup(pci, cpu_addr);
150 
151 	if (pci->iatu_unroll_enabled) {
152 		dw_pcie_prog_outbound_atu_unroll(pci, index, type, cpu_addr,
153 						 pci_addr, size);
154 		return;
155 	}
156 
157 	dw_pcie_writel_dbi(pci, PCIE_ATU_VIEWPORT,
158 			   PCIE_ATU_REGION_OUTBOUND | index);
159 	dw_pcie_writel_dbi(pci, PCIE_ATU_LOWER_BASE,
160 			   lower_32_bits(cpu_addr));
161 	dw_pcie_writel_dbi(pci, PCIE_ATU_UPPER_BASE,
162 			   upper_32_bits(cpu_addr));
163 	dw_pcie_writel_dbi(pci, PCIE_ATU_LIMIT,
164 			   lower_32_bits(cpu_addr + size - 1));
165 	dw_pcie_writel_dbi(pci, PCIE_ATU_LOWER_TARGET,
166 			   lower_32_bits(pci_addr));
167 	dw_pcie_writel_dbi(pci, PCIE_ATU_UPPER_TARGET,
168 			   upper_32_bits(pci_addr));
169 	dw_pcie_writel_dbi(pci, PCIE_ATU_CR1, type);
170 	dw_pcie_writel_dbi(pci, PCIE_ATU_CR2, PCIE_ATU_ENABLE);
171 
172 	/*
173 	 * Make sure ATU enable takes effect before any subsequent config
174 	 * and I/O accesses.
175 	 */
176 	for (retries = 0; retries < LINK_WAIT_MAX_IATU_RETRIES; retries++) {
177 		val = dw_pcie_readl_dbi(pci, PCIE_ATU_CR2);
178 		if (val & PCIE_ATU_ENABLE)
179 			return;
180 
181 		usleep_range(LINK_WAIT_IATU_MIN, LINK_WAIT_IATU_MAX);
182 	}
183 	dev_err(pci->dev, "Outbound iATU is not being enabled\n");
184 }
185 
186 static u32 dw_pcie_readl_ib_unroll(struct dw_pcie *pci, u32 index, u32 reg)
187 {
188 	u32 offset = PCIE_GET_ATU_INB_UNR_REG_OFFSET(index);
189 
190 	return dw_pcie_readl_dbi(pci, offset + reg);
191 }
192 
193 static void dw_pcie_writel_ib_unroll(struct dw_pcie *pci, u32 index, u32 reg,
194 				     u32 val)
195 {
196 	u32 offset = PCIE_GET_ATU_INB_UNR_REG_OFFSET(index);
197 
198 	dw_pcie_writel_dbi(pci, offset + reg, val);
199 }
200 
201 static int dw_pcie_prog_inbound_atu_unroll(struct dw_pcie *pci, int index,
202 					   int bar, u64 cpu_addr,
203 					   enum dw_pcie_as_type as_type)
204 {
205 	int type;
206 	u32 retries, val;
207 
208 	dw_pcie_writel_ib_unroll(pci, index, PCIE_ATU_UNR_LOWER_TARGET,
209 				 lower_32_bits(cpu_addr));
210 	dw_pcie_writel_ib_unroll(pci, index, PCIE_ATU_UNR_UPPER_TARGET,
211 				 upper_32_bits(cpu_addr));
212 
213 	switch (as_type) {
214 	case DW_PCIE_AS_MEM:
215 		type = PCIE_ATU_TYPE_MEM;
216 		break;
217 	case DW_PCIE_AS_IO:
218 		type = PCIE_ATU_TYPE_IO;
219 		break;
220 	default:
221 		return -EINVAL;
222 	}
223 
224 	dw_pcie_writel_ib_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL1, type);
225 	dw_pcie_writel_ib_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL2,
226 				 PCIE_ATU_ENABLE |
227 				 PCIE_ATU_BAR_MODE_ENABLE | (bar << 8));
228 
229 	/*
230 	 * Make sure ATU enable takes effect before any subsequent config
231 	 * and I/O accesses.
232 	 */
233 	for (retries = 0; retries < LINK_WAIT_MAX_IATU_RETRIES; retries++) {
234 		val = dw_pcie_readl_ib_unroll(pci, index,
235 					      PCIE_ATU_UNR_REGION_CTRL2);
236 		if (val & PCIE_ATU_ENABLE)
237 			return 0;
238 
239 		usleep_range(LINK_WAIT_IATU_MIN, LINK_WAIT_IATU_MAX);
240 	}
241 	dev_err(pci->dev, "Inbound iATU is not being enabled\n");
242 
243 	return -EBUSY;
244 }
245 
246 int dw_pcie_prog_inbound_atu(struct dw_pcie *pci, int index, int bar,
247 			     u64 cpu_addr, enum dw_pcie_as_type as_type)
248 {
249 	int type;
250 	u32 retries, val;
251 
252 	if (pci->iatu_unroll_enabled)
253 		return dw_pcie_prog_inbound_atu_unroll(pci, index, bar,
254 						       cpu_addr, as_type);
255 
256 	dw_pcie_writel_dbi(pci, PCIE_ATU_VIEWPORT, PCIE_ATU_REGION_INBOUND |
257 			   index);
258 	dw_pcie_writel_dbi(pci, PCIE_ATU_LOWER_TARGET, lower_32_bits(cpu_addr));
259 	dw_pcie_writel_dbi(pci, PCIE_ATU_UPPER_TARGET, upper_32_bits(cpu_addr));
260 
261 	switch (as_type) {
262 	case DW_PCIE_AS_MEM:
263 		type = PCIE_ATU_TYPE_MEM;
264 		break;
265 	case DW_PCIE_AS_IO:
266 		type = PCIE_ATU_TYPE_IO;
267 		break;
268 	default:
269 		return -EINVAL;
270 	}
271 
272 	dw_pcie_writel_dbi(pci, PCIE_ATU_CR1, type);
273 	dw_pcie_writel_dbi(pci, PCIE_ATU_CR2, PCIE_ATU_ENABLE
274 			   | PCIE_ATU_BAR_MODE_ENABLE | (bar << 8));
275 
276 	/*
277 	 * Make sure ATU enable takes effect before any subsequent config
278 	 * and I/O accesses.
279 	 */
280 	for (retries = 0; retries < LINK_WAIT_MAX_IATU_RETRIES; retries++) {
281 		val = dw_pcie_readl_dbi(pci, PCIE_ATU_CR2);
282 		if (val & PCIE_ATU_ENABLE)
283 			return 0;
284 
285 		usleep_range(LINK_WAIT_IATU_MIN, LINK_WAIT_IATU_MAX);
286 	}
287 	dev_err(pci->dev, "Inbound iATU is not being enabled\n");
288 
289 	return -EBUSY;
290 }
291 
292 void dw_pcie_disable_atu(struct dw_pcie *pci, int index,
293 			 enum dw_pcie_region_type type)
294 {
295 	int region;
296 
297 	switch (type) {
298 	case DW_PCIE_REGION_INBOUND:
299 		region = PCIE_ATU_REGION_INBOUND;
300 		break;
301 	case DW_PCIE_REGION_OUTBOUND:
302 		region = PCIE_ATU_REGION_OUTBOUND;
303 		break;
304 	default:
305 		return;
306 	}
307 
308 	dw_pcie_writel_dbi(pci, PCIE_ATU_VIEWPORT, region | index);
309 	dw_pcie_writel_dbi(pci, PCIE_ATU_CR2, ~PCIE_ATU_ENABLE);
310 }
311 
312 int dw_pcie_wait_for_link(struct dw_pcie *pci)
313 {
314 	int retries;
315 
316 	/* Check if the link is up or not */
317 	for (retries = 0; retries < LINK_WAIT_MAX_RETRIES; retries++) {
318 		if (dw_pcie_link_up(pci)) {
319 			dev_info(pci->dev, "Link up\n");
320 			return 0;
321 		}
322 		usleep_range(LINK_WAIT_USLEEP_MIN, LINK_WAIT_USLEEP_MAX);
323 	}
324 
325 	dev_err(pci->dev, "Phy link never came up\n");
326 
327 	return -ETIMEDOUT;
328 }
329 
330 int dw_pcie_link_up(struct dw_pcie *pci)
331 {
332 	u32 val;
333 
334 	if (pci->ops->link_up)
335 		return pci->ops->link_up(pci);
336 
337 	val = readl(pci->dbi_base + PCIE_PHY_DEBUG_R1);
338 	return ((val & PCIE_PHY_DEBUG_R1_LINK_UP) &&
339 		(!(val & PCIE_PHY_DEBUG_R1_LINK_IN_TRAINING)));
340 }
341 
342 void dw_pcie_setup(struct dw_pcie *pci)
343 {
344 	int ret;
345 	u32 val;
346 	u32 lanes;
347 	struct device *dev = pci->dev;
348 	struct device_node *np = dev->of_node;
349 
350 	ret = of_property_read_u32(np, "num-lanes", &lanes);
351 	if (ret)
352 		lanes = 0;
353 
354 	/* Set the number of lanes */
355 	val = dw_pcie_readl_dbi(pci, PCIE_PORT_LINK_CONTROL);
356 	val &= ~PORT_LINK_MODE_MASK;
357 	switch (lanes) {
358 	case 1:
359 		val |= PORT_LINK_MODE_1_LANES;
360 		break;
361 	case 2:
362 		val |= PORT_LINK_MODE_2_LANES;
363 		break;
364 	case 4:
365 		val |= PORT_LINK_MODE_4_LANES;
366 		break;
367 	case 8:
368 		val |= PORT_LINK_MODE_8_LANES;
369 		break;
370 	default:
371 		dev_err(pci->dev, "num-lanes %u: invalid value\n", lanes);
372 		return;
373 	}
374 	dw_pcie_writel_dbi(pci, PCIE_PORT_LINK_CONTROL, val);
375 
376 	/* Set link width speed control register */
377 	val = dw_pcie_readl_dbi(pci, PCIE_LINK_WIDTH_SPEED_CONTROL);
378 	val &= ~PORT_LOGIC_LINK_WIDTH_MASK;
379 	switch (lanes) {
380 	case 1:
381 		val |= PORT_LOGIC_LINK_WIDTH_1_LANES;
382 		break;
383 	case 2:
384 		val |= PORT_LOGIC_LINK_WIDTH_2_LANES;
385 		break;
386 	case 4:
387 		val |= PORT_LOGIC_LINK_WIDTH_4_LANES;
388 		break;
389 	case 8:
390 		val |= PORT_LOGIC_LINK_WIDTH_8_LANES;
391 		break;
392 	}
393 	dw_pcie_writel_dbi(pci, PCIE_LINK_WIDTH_SPEED_CONTROL, val);
394 }
395