1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright 2017 NXP
4  * Copyright 2014-2015 Freescale Semiconductor, Inc.
5  * Layerscape PCIe driver
6  */
7 
8 #include <common.h>
9 #include <asm/arch/fsl_serdes.h>
10 #include <pci.h>
11 #include <asm/io.h>
12 #include <errno.h>
13 #include <malloc.h>
14 #include <dm.h>
15 #if defined(CONFIG_FSL_LSCH2) || defined(CONFIG_FSL_LSCH3) || \
16 	defined(CONFIG_ARM)
17 #include <asm/arch/clock.h>
18 #endif
19 #include "pcie_layerscape.h"
20 
21 DECLARE_GLOBAL_DATA_PTR;
22 
23 LIST_HEAD(ls_pcie_list);
24 
25 static unsigned int dbi_readl(struct ls_pcie *pcie, unsigned int offset)
26 {
27 	return in_le32(pcie->dbi + offset);
28 }
29 
30 static void dbi_writel(struct ls_pcie *pcie, unsigned int value,
31 		       unsigned int offset)
32 {
33 	out_le32(pcie->dbi + offset, value);
34 }
35 
36 static unsigned int ctrl_readl(struct ls_pcie *pcie, unsigned int offset)
37 {
38 	if (pcie->big_endian)
39 		return in_be32(pcie->ctrl + offset);
40 	else
41 		return in_le32(pcie->ctrl + offset);
42 }
43 
44 static void ctrl_writel(struct ls_pcie *pcie, unsigned int value,
45 			unsigned int offset)
46 {
47 	if (pcie->big_endian)
48 		out_be32(pcie->ctrl + offset, value);
49 	else
50 		out_le32(pcie->ctrl + offset, value);
51 }
52 
53 static int ls_pcie_ltssm(struct ls_pcie *pcie)
54 {
55 	u32 state;
56 	uint svr;
57 
58 	svr = get_svr();
59 	if (((svr >> SVR_VAR_PER_SHIFT) & SVR_LS102XA_MASK) == SVR_LS102XA) {
60 		state = ctrl_readl(pcie, LS1021_PEXMSCPORTSR(pcie->idx));
61 		state = (state >> LS1021_LTSSM_STATE_SHIFT) & LTSSM_STATE_MASK;
62 	} else {
63 		state = ctrl_readl(pcie, PCIE_PF_DBG) & LTSSM_STATE_MASK;
64 	}
65 
66 	return state;
67 }
68 
69 static int ls_pcie_link_up(struct ls_pcie *pcie)
70 {
71 	int ltssm;
72 
73 	ltssm = ls_pcie_ltssm(pcie);
74 	if (ltssm < LTSSM_PCIE_L0)
75 		return 0;
76 
77 	return 1;
78 }
79 
80 static void ls_pcie_cfg0_set_busdev(struct ls_pcie *pcie, u32 busdev)
81 {
82 	dbi_writel(pcie, PCIE_ATU_REGION_OUTBOUND | PCIE_ATU_REGION_INDEX0,
83 		   PCIE_ATU_VIEWPORT);
84 	dbi_writel(pcie, busdev, PCIE_ATU_LOWER_TARGET);
85 }
86 
87 static void ls_pcie_cfg1_set_busdev(struct ls_pcie *pcie, u32 busdev)
88 {
89 	dbi_writel(pcie, PCIE_ATU_REGION_OUTBOUND | PCIE_ATU_REGION_INDEX1,
90 		   PCIE_ATU_VIEWPORT);
91 	dbi_writel(pcie, busdev, PCIE_ATU_LOWER_TARGET);
92 }
93 
94 static void ls_pcie_atu_outbound_set(struct ls_pcie *pcie, int idx, int type,
95 				      u64 phys, u64 bus_addr, pci_size_t size)
96 {
97 	dbi_writel(pcie, PCIE_ATU_REGION_OUTBOUND | idx, PCIE_ATU_VIEWPORT);
98 	dbi_writel(pcie, (u32)phys, PCIE_ATU_LOWER_BASE);
99 	dbi_writel(pcie, phys >> 32, PCIE_ATU_UPPER_BASE);
100 	dbi_writel(pcie, (u32)phys + size - 1, PCIE_ATU_LIMIT);
101 	dbi_writel(pcie, (u32)bus_addr, PCIE_ATU_LOWER_TARGET);
102 	dbi_writel(pcie, bus_addr >> 32, PCIE_ATU_UPPER_TARGET);
103 	dbi_writel(pcie, type, PCIE_ATU_CR1);
104 	dbi_writel(pcie, PCIE_ATU_ENABLE, PCIE_ATU_CR2);
105 }
106 
107 /* Use bar match mode and MEM type as default */
108 static void ls_pcie_atu_inbound_set(struct ls_pcie *pcie, int idx,
109 				     int bar, u64 phys)
110 {
111 	dbi_writel(pcie, PCIE_ATU_REGION_INBOUND | idx, PCIE_ATU_VIEWPORT);
112 	dbi_writel(pcie, (u32)phys, PCIE_ATU_LOWER_TARGET);
113 	dbi_writel(pcie, phys >> 32, PCIE_ATU_UPPER_TARGET);
114 	dbi_writel(pcie, PCIE_ATU_TYPE_MEM, PCIE_ATU_CR1);
115 	dbi_writel(pcie, PCIE_ATU_ENABLE | PCIE_ATU_BAR_MODE_ENABLE |
116 		   PCIE_ATU_BAR_NUM(bar), PCIE_ATU_CR2);
117 }
118 
119 static void ls_pcie_dump_atu(struct ls_pcie *pcie)
120 {
121 	int i;
122 
123 	for (i = 0; i < PCIE_ATU_REGION_NUM; i++) {
124 		dbi_writel(pcie, PCIE_ATU_REGION_OUTBOUND | i,
125 			   PCIE_ATU_VIEWPORT);
126 		debug("iATU%d:\n", i);
127 		debug("\tLOWER PHYS 0x%08x\n",
128 		      dbi_readl(pcie, PCIE_ATU_LOWER_BASE));
129 		debug("\tUPPER PHYS 0x%08x\n",
130 		      dbi_readl(pcie, PCIE_ATU_UPPER_BASE));
131 		debug("\tLOWER BUS  0x%08x\n",
132 		      dbi_readl(pcie, PCIE_ATU_LOWER_TARGET));
133 		debug("\tUPPER BUS  0x%08x\n",
134 		      dbi_readl(pcie, PCIE_ATU_UPPER_TARGET));
135 		debug("\tLIMIT      0x%08x\n",
136 		      readl(pcie->dbi + PCIE_ATU_LIMIT));
137 		debug("\tCR1        0x%08x\n",
138 		      dbi_readl(pcie, PCIE_ATU_CR1));
139 		debug("\tCR2        0x%08x\n",
140 		      dbi_readl(pcie, PCIE_ATU_CR2));
141 	}
142 }
143 
144 static void ls_pcie_setup_atu(struct ls_pcie *pcie)
145 {
146 	struct pci_region *io, *mem, *pref;
147 	unsigned long long offset = 0;
148 	int idx = 0;
149 	uint svr;
150 
151 	svr = get_svr();
152 	if (((svr >> SVR_VAR_PER_SHIFT) & SVR_LS102XA_MASK) == SVR_LS102XA) {
153 		offset = LS1021_PCIE_SPACE_OFFSET +
154 			 LS1021_PCIE_SPACE_SIZE * pcie->idx;
155 	}
156 
157 	/* ATU 0 : OUTBOUND : CFG0 */
158 	ls_pcie_atu_outbound_set(pcie, PCIE_ATU_REGION_INDEX0,
159 				 PCIE_ATU_TYPE_CFG0,
160 				 pcie->cfg_res.start + offset,
161 				 0,
162 				 fdt_resource_size(&pcie->cfg_res) / 2);
163 	/* ATU 1 : OUTBOUND : CFG1 */
164 	ls_pcie_atu_outbound_set(pcie, PCIE_ATU_REGION_INDEX1,
165 				 PCIE_ATU_TYPE_CFG1,
166 				 pcie->cfg_res.start + offset +
167 				 fdt_resource_size(&pcie->cfg_res) / 2,
168 				 0,
169 				 fdt_resource_size(&pcie->cfg_res) / 2);
170 
171 	pci_get_regions(pcie->bus, &io, &mem, &pref);
172 	idx = PCIE_ATU_REGION_INDEX1 + 1;
173 
174 	/* Fix the pcie memory map for LS2088A series SoCs */
175 	svr = (svr >> SVR_VAR_PER_SHIFT) & 0xFFFFFE;
176 	if (svr == SVR_LS2088A || svr == SVR_LS2084A ||
177 	    svr == SVR_LS2048A || svr == SVR_LS2044A ||
178 	    svr == SVR_LS2081A || svr == SVR_LS2041A) {
179 		if (io)
180 			io->phys_start = (io->phys_start &
181 					 (PCIE_PHYS_SIZE - 1)) +
182 					 LS2088A_PCIE1_PHYS_ADDR +
183 					 LS2088A_PCIE_PHYS_SIZE * pcie->idx;
184 		if (mem)
185 			mem->phys_start = (mem->phys_start &
186 					 (PCIE_PHYS_SIZE - 1)) +
187 					 LS2088A_PCIE1_PHYS_ADDR +
188 					 LS2088A_PCIE_PHYS_SIZE * pcie->idx;
189 		if (pref)
190 			pref->phys_start = (pref->phys_start &
191 					 (PCIE_PHYS_SIZE - 1)) +
192 					 LS2088A_PCIE1_PHYS_ADDR +
193 					 LS2088A_PCIE_PHYS_SIZE * pcie->idx;
194 	}
195 
196 	if (io)
197 		/* ATU : OUTBOUND : IO */
198 		ls_pcie_atu_outbound_set(pcie, idx++,
199 					 PCIE_ATU_TYPE_IO,
200 					 io->phys_start + offset,
201 					 io->bus_start,
202 					 io->size);
203 
204 	if (mem)
205 		/* ATU : OUTBOUND : MEM */
206 		ls_pcie_atu_outbound_set(pcie, idx++,
207 					 PCIE_ATU_TYPE_MEM,
208 					 mem->phys_start + offset,
209 					 mem->bus_start,
210 					 mem->size);
211 
212 	if (pref)
213 		/* ATU : OUTBOUND : pref */
214 		ls_pcie_atu_outbound_set(pcie, idx++,
215 					 PCIE_ATU_TYPE_MEM,
216 					 pref->phys_start + offset,
217 					 pref->bus_start,
218 					 pref->size);
219 
220 	ls_pcie_dump_atu(pcie);
221 }
222 
223 /* Return 0 if the address is valid, -errno if not valid */
224 static int ls_pcie_addr_valid(struct ls_pcie *pcie, pci_dev_t bdf)
225 {
226 	struct udevice *bus = pcie->bus;
227 
228 	if (pcie->mode == PCI_HEADER_TYPE_NORMAL)
229 		return -ENODEV;
230 
231 	if (!pcie->enabled)
232 		return -ENXIO;
233 
234 	if (PCI_BUS(bdf) < bus->seq)
235 		return -EINVAL;
236 
237 	if ((PCI_BUS(bdf) > bus->seq) && (!ls_pcie_link_up(pcie)))
238 		return -EINVAL;
239 
240 	if (PCI_BUS(bdf) <= (bus->seq + 1) && (PCI_DEV(bdf) > 0))
241 		return -EINVAL;
242 
243 	return 0;
244 }
245 
246 int ls_pcie_conf_address(struct udevice *bus, pci_dev_t bdf,
247 			 uint offset, void **paddress)
248 {
249 	struct ls_pcie *pcie = dev_get_priv(bus);
250 	u32 busdev;
251 
252 	if (ls_pcie_addr_valid(pcie, bdf))
253 		return -EINVAL;
254 
255 	if (PCI_BUS(bdf) == bus->seq) {
256 		*paddress = pcie->dbi + offset;
257 		return 0;
258 	}
259 
260 	busdev = PCIE_ATU_BUS(PCI_BUS(bdf) - bus->seq) |
261 		 PCIE_ATU_DEV(PCI_DEV(bdf)) |
262 		 PCIE_ATU_FUNC(PCI_FUNC(bdf));
263 
264 	if (PCI_BUS(bdf) == bus->seq + 1) {
265 		ls_pcie_cfg0_set_busdev(pcie, busdev);
266 		*paddress = pcie->cfg0 + offset;
267 	} else {
268 		ls_pcie_cfg1_set_busdev(pcie, busdev);
269 		*paddress = pcie->cfg1 + offset;
270 	}
271 	return 0;
272 }
273 
274 static int ls_pcie_read_config(struct udevice *bus, pci_dev_t bdf,
275 			       uint offset, ulong *valuep,
276 			       enum pci_size_t size)
277 {
278 	return pci_generic_mmap_read_config(bus, ls_pcie_conf_address,
279 					    bdf, offset, valuep, size);
280 }
281 
282 static int ls_pcie_write_config(struct udevice *bus, pci_dev_t bdf,
283 				uint offset, ulong value,
284 				enum pci_size_t size)
285 {
286 	return pci_generic_mmap_write_config(bus, ls_pcie_conf_address,
287 					     bdf, offset, value, size);
288 }
289 
290 /* Clear multi-function bit */
291 static void ls_pcie_clear_multifunction(struct ls_pcie *pcie)
292 {
293 	writeb(PCI_HEADER_TYPE_BRIDGE, pcie->dbi + PCI_HEADER_TYPE);
294 }
295 
296 /* Fix class value */
297 static void ls_pcie_fix_class(struct ls_pcie *pcie)
298 {
299 	writew(PCI_CLASS_BRIDGE_PCI, pcie->dbi + PCI_CLASS_DEVICE);
300 }
301 
302 /* Drop MSG TLP except for Vendor MSG */
303 static void ls_pcie_drop_msg_tlp(struct ls_pcie *pcie)
304 {
305 	u32 val;
306 
307 	val = dbi_readl(pcie, PCIE_STRFMR1);
308 	val &= 0xDFFFFFFF;
309 	dbi_writel(pcie, val, PCIE_STRFMR1);
310 }
311 
312 /* Disable all bars in RC mode */
313 static void ls_pcie_disable_bars(struct ls_pcie *pcie)
314 {
315 	u32 sriov;
316 
317 	sriov = in_le32(pcie->dbi + PCIE_SRIOV);
318 
319 	/*
320 	 * TODO: For PCIe controller with SRIOV, the method to disable bars
321 	 * is different and more complex, so will add later.
322 	 */
323 	if (PCI_EXT_CAP_ID(sriov) == PCI_EXT_CAP_ID_SRIOV)
324 		return;
325 
326 	dbi_writel(pcie, 0, PCIE_CS2_OFFSET + PCI_BASE_ADDRESS_0);
327 	dbi_writel(pcie, 0, PCIE_CS2_OFFSET + PCI_BASE_ADDRESS_1);
328 	dbi_writel(pcie, 0, PCIE_CS2_OFFSET + PCI_ROM_ADDRESS1);
329 }
330 
331 static void ls_pcie_setup_ctrl(struct ls_pcie *pcie)
332 {
333 	ls_pcie_setup_atu(pcie);
334 
335 	dbi_writel(pcie, 1, PCIE_DBI_RO_WR_EN);
336 	ls_pcie_fix_class(pcie);
337 	ls_pcie_clear_multifunction(pcie);
338 	ls_pcie_drop_msg_tlp(pcie);
339 	dbi_writel(pcie, 0, PCIE_DBI_RO_WR_EN);
340 
341 	ls_pcie_disable_bars(pcie);
342 }
343 
344 static void ls_pcie_ep_setup_atu(struct ls_pcie *pcie)
345 {
346 	u64 phys = CONFIG_SYS_PCI_EP_MEMORY_BASE;
347 
348 	/* ATU 0 : INBOUND : map BAR0 */
349 	ls_pcie_atu_inbound_set(pcie, 0, 0, phys);
350 	/* ATU 1 : INBOUND : map BAR1 */
351 	phys += PCIE_BAR1_SIZE;
352 	ls_pcie_atu_inbound_set(pcie, 1, 1, phys);
353 	/* ATU 2 : INBOUND : map BAR2 */
354 	phys += PCIE_BAR2_SIZE;
355 	ls_pcie_atu_inbound_set(pcie, 2, 2, phys);
356 	/* ATU 3 : INBOUND : map BAR4 */
357 	phys = CONFIG_SYS_PCI_EP_MEMORY_BASE + PCIE_BAR4_SIZE;
358 	ls_pcie_atu_inbound_set(pcie, 3, 4, phys);
359 
360 	/* ATU 0 : OUTBOUND : map MEM */
361 	ls_pcie_atu_outbound_set(pcie, 0,
362 				 PCIE_ATU_TYPE_MEM,
363 				 pcie->cfg_res.start,
364 				 0,
365 				 CONFIG_SYS_PCI_MEMORY_SIZE);
366 }
367 
368 /* BAR0 and BAR1 are 32bit BAR2 and BAR4 are 64bit */
369 static void ls_pcie_ep_setup_bar(void *bar_base, int bar, u32 size)
370 {
371 	/* The least inbound window is 4KiB */
372 	if (size < 4 * 1024)
373 		return;
374 
375 	switch (bar) {
376 	case 0:
377 		writel(size - 1, bar_base + PCI_BASE_ADDRESS_0);
378 		break;
379 	case 1:
380 		writel(size - 1, bar_base + PCI_BASE_ADDRESS_1);
381 		break;
382 	case 2:
383 		writel(size - 1, bar_base + PCI_BASE_ADDRESS_2);
384 		writel(0, bar_base + PCI_BASE_ADDRESS_3);
385 		break;
386 	case 4:
387 		writel(size - 1, bar_base + PCI_BASE_ADDRESS_4);
388 		writel(0, bar_base + PCI_BASE_ADDRESS_5);
389 		break;
390 	default:
391 		break;
392 	}
393 }
394 
395 static void ls_pcie_ep_setup_bars(void *bar_base)
396 {
397 	/* BAR0 - 32bit - 4K configuration */
398 	ls_pcie_ep_setup_bar(bar_base, 0, PCIE_BAR0_SIZE);
399 	/* BAR1 - 32bit - 8K MSIX*/
400 	ls_pcie_ep_setup_bar(bar_base, 1, PCIE_BAR1_SIZE);
401 	/* BAR2 - 64bit - 4K MEM desciptor */
402 	ls_pcie_ep_setup_bar(bar_base, 2, PCIE_BAR2_SIZE);
403 	/* BAR4 - 64bit - 1M MEM*/
404 	ls_pcie_ep_setup_bar(bar_base, 4, PCIE_BAR4_SIZE);
405 }
406 
407 static void ls_pcie_ep_enable_cfg(struct ls_pcie *pcie)
408 {
409 	ctrl_writel(pcie, PCIE_CONFIG_READY, PCIE_PF_CONFIG);
410 }
411 
412 static void ls_pcie_setup_ep(struct ls_pcie *pcie)
413 {
414 	u32 sriov;
415 
416 	sriov = readl(pcie->dbi + PCIE_SRIOV);
417 	if (PCI_EXT_CAP_ID(sriov) == PCI_EXT_CAP_ID_SRIOV) {
418 		int pf, vf;
419 
420 		for (pf = 0; pf < PCIE_PF_NUM; pf++) {
421 			for (vf = 0; vf <= PCIE_VF_NUM; vf++) {
422 				ctrl_writel(pcie, PCIE_LCTRL0_VAL(pf, vf),
423 					    PCIE_PF_VF_CTRL);
424 
425 				ls_pcie_ep_setup_bars(pcie->dbi);
426 				ls_pcie_ep_setup_atu(pcie);
427 			}
428 		}
429 		/* Disable CFG2 */
430 		ctrl_writel(pcie, 0, PCIE_PF_VF_CTRL);
431 	} else {
432 		ls_pcie_ep_setup_bars(pcie->dbi + PCIE_NO_SRIOV_BAR_BASE);
433 		ls_pcie_ep_setup_atu(pcie);
434 	}
435 
436 	ls_pcie_ep_enable_cfg(pcie);
437 }
438 
439 static int ls_pcie_probe(struct udevice *dev)
440 {
441 	struct ls_pcie *pcie = dev_get_priv(dev);
442 	const void *fdt = gd->fdt_blob;
443 	int node = dev_of_offset(dev);
444 	u16 link_sta;
445 	uint svr;
446 	int ret;
447 	fdt_size_t cfg_size;
448 
449 	pcie->bus = dev;
450 
451 	ret = fdt_get_named_resource(fdt, node, "reg", "reg-names",
452 				     "dbi", &pcie->dbi_res);
453 	if (ret) {
454 		printf("ls-pcie: resource \"dbi\" not found\n");
455 		return ret;
456 	}
457 
458 	pcie->idx = (pcie->dbi_res.start - PCIE_SYS_BASE_ADDR) / PCIE_CCSR_SIZE;
459 
460 	list_add(&pcie->list, &ls_pcie_list);
461 
462 	pcie->enabled = is_serdes_configured(PCIE_SRDS_PRTCL(pcie->idx));
463 	if (!pcie->enabled) {
464 		printf("PCIe%d: %s disabled\n", pcie->idx, dev->name);
465 		return 0;
466 	}
467 
468 	pcie->dbi = map_physmem(pcie->dbi_res.start,
469 				fdt_resource_size(&pcie->dbi_res),
470 				MAP_NOCACHE);
471 
472 	ret = fdt_get_named_resource(fdt, node, "reg", "reg-names",
473 				     "lut", &pcie->lut_res);
474 	if (!ret)
475 		pcie->lut = map_physmem(pcie->lut_res.start,
476 					fdt_resource_size(&pcie->lut_res),
477 					MAP_NOCACHE);
478 
479 	ret = fdt_get_named_resource(fdt, node, "reg", "reg-names",
480 				     "ctrl", &pcie->ctrl_res);
481 	if (!ret)
482 		pcie->ctrl = map_physmem(pcie->ctrl_res.start,
483 					 fdt_resource_size(&pcie->ctrl_res),
484 					 MAP_NOCACHE);
485 	if (!pcie->ctrl)
486 		pcie->ctrl = pcie->lut;
487 
488 	if (!pcie->ctrl) {
489 		printf("%s: NOT find CTRL\n", dev->name);
490 		return -1;
491 	}
492 
493 	ret = fdt_get_named_resource(fdt, node, "reg", "reg-names",
494 				     "config", &pcie->cfg_res);
495 	if (ret) {
496 		printf("%s: resource \"config\" not found\n", dev->name);
497 		return ret;
498 	}
499 
500 	/*
501 	 * Fix the pcie memory map address and PF control registers address
502 	 * for LS2088A series SoCs
503 	 */
504 	svr = get_svr();
505 	svr = (svr >> SVR_VAR_PER_SHIFT) & 0xFFFFFE;
506 	if (svr == SVR_LS2088A || svr == SVR_LS2084A ||
507 	    svr == SVR_LS2048A || svr == SVR_LS2044A ||
508 	    svr == SVR_LS2081A || svr == SVR_LS2041A) {
509 		cfg_size = fdt_resource_size(&pcie->cfg_res);
510 		pcie->cfg_res.start = LS2088A_PCIE1_PHYS_ADDR +
511 					LS2088A_PCIE_PHYS_SIZE * pcie->idx;
512 		pcie->cfg_res.end = pcie->cfg_res.start + cfg_size;
513 		pcie->ctrl = pcie->lut + 0x40000;
514 	}
515 
516 	pcie->cfg0 = map_physmem(pcie->cfg_res.start,
517 				 fdt_resource_size(&pcie->cfg_res),
518 				 MAP_NOCACHE);
519 	pcie->cfg1 = pcie->cfg0 + fdt_resource_size(&pcie->cfg_res) / 2;
520 
521 	pcie->big_endian = fdtdec_get_bool(fdt, node, "big-endian");
522 
523 	debug("%s dbi:%lx lut:%lx ctrl:0x%lx cfg0:0x%lx, big-endian:%d\n",
524 	      dev->name, (unsigned long)pcie->dbi, (unsigned long)pcie->lut,
525 	      (unsigned long)pcie->ctrl, (unsigned long)pcie->cfg0,
526 	      pcie->big_endian);
527 
528 	pcie->mode = readb(pcie->dbi + PCI_HEADER_TYPE) & 0x7f;
529 
530 	if (pcie->mode == PCI_HEADER_TYPE_NORMAL) {
531 		printf("PCIe%u: %s %s", pcie->idx, dev->name, "Endpoint");
532 			ls_pcie_setup_ep(pcie);
533 	} else {
534 		printf("PCIe%u: %s %s", pcie->idx, dev->name, "Root Complex");
535 			ls_pcie_setup_ctrl(pcie);
536 	}
537 
538 	if (!ls_pcie_link_up(pcie)) {
539 		/* Let the user know there's no PCIe link */
540 		printf(": no link\n");
541 		return 0;
542 	}
543 
544 	/* Print the negotiated PCIe link width */
545 	link_sta = readw(pcie->dbi + PCIE_LINK_STA);
546 	printf(": x%d gen%d\n", (link_sta & PCIE_LINK_WIDTH_MASK) >> 4,
547 	       link_sta & PCIE_LINK_SPEED_MASK);
548 
549 	return 0;
550 }
551 
552 static const struct dm_pci_ops ls_pcie_ops = {
553 	.read_config	= ls_pcie_read_config,
554 	.write_config	= ls_pcie_write_config,
555 };
556 
557 static const struct udevice_id ls_pcie_ids[] = {
558 	{ .compatible = "fsl,ls-pcie" },
559 	{ }
560 };
561 
562 U_BOOT_DRIVER(pci_layerscape) = {
563 	.name = "pci_layerscape",
564 	.id = UCLASS_PCI,
565 	.of_match = ls_pcie_ids,
566 	.ops = &ls_pcie_ops,
567 	.probe	= ls_pcie_probe,
568 	.priv_auto_alloc_size = sizeof(struct ls_pcie),
569 };
570