1 // SPDX-License-Identifier: GPL-2.0
3 * MediaTek PCIe host controller driver.
5 * Copyright (c) 2017-2019 MediaTek Inc.
6 * Author: Ryder Lee <ryder.lee@mediatek.com>
7 * Honghui Zhang <honghui.zhang@mediatek.com>
13 #include <generic-phy.h>
19 #include <dm/devres.h>
20 #include <linux/bitops.h>
21 #include <linux/iopoll.h>
22 #include <linux/list.h>
23 #include "pci_internal.h"
25 /* PCIe shared registers */
26 #define PCIE_SYS_CFG 0x00
27 #define PCIE_INT_ENABLE 0x0c
28 #define PCIE_CFG_ADDR 0x20
29 #define PCIE_CFG_DATA 0x24
31 /* PCIe per port registers */
32 #define PCIE_BAR0_SETUP 0x10
33 #define PCIE_CLASS 0x34
34 #define PCIE_LINK_STATUS 0x50
36 #define PCIE_PORT_INT_EN(x) BIT(20 + (x))
37 #define PCIE_PORT_PERST(x) BIT(1 + (x))
38 #define PCIE_PORT_LINKUP BIT(0)
39 #define PCIE_BAR_MAP_MAX GENMASK(31, 16)
41 #define PCIE_BAR_ENABLE BIT(0)
42 #define PCIE_REVISION_ID BIT(0)
43 #define PCIE_CLASS_CODE (0x60400 << 8)
45 /* MediaTek specific configuration registers */
46 #define PCIE_FTS_NUM 0x70c
47 #define PCIE_FTS_NUM_MASK GENMASK(15, 8)
48 #define PCIE_FTS_NUM_L0(x) ((x) & 0xff << 8)
50 #define PCIE_FC_CREDIT 0x73c
51 #define PCIE_FC_CREDIT_MASK (GENMASK(31, 31) | GENMASK(28, 16))
52 #define PCIE_FC_CREDIT_VAL(x) ((x) << 16)
54 /* PCIe V2 share registers */
55 #define PCIE_SYS_CFG_V2 0x0
56 #define PCIE_CSR_LTSSM_EN(x) BIT(0 + (x) * 8)
57 #define PCIE_CSR_ASPM_L1_EN(x) BIT(1 + (x) * 8)
59 /* PCIe V2 per-port registers */
60 #define PCIE_CONF_VEND_ID 0x100
61 #define PCIE_CONF_DEVICE_ID 0x102
62 #define PCIE_CONF_CLASS_ID 0x106
64 #define PCIE_AHB_TRANS_BASE0_L 0x438
65 #define PCIE_AHB_TRANS_BASE0_H 0x43c
66 #define AHB2PCIE_SIZE(x) ((x) & GENMASK(4, 0))
67 #define PCIE_AXI_WINDOW0 0x448
68 #define WIN_ENABLE BIT(7)
71 * Define PCIe to AHB window size as 2^33 to support max 8GB address space
72 * translate, support least 4GB DRAM size access from EP DMA(physical DRAM
73 * start from 0x40000000).
75 #define PCIE2AHB_SIZE 0x21
77 /* PCIe V2 configuration transaction header */
78 #define PCIE_CFG_HEADER0 0x460
79 #define PCIE_CFG_HEADER1 0x464
80 #define PCIE_CFG_HEADER2 0x468
81 #define PCIE_CFG_WDATA 0x470
82 #define PCIE_APP_TLP_REQ 0x488
83 #define PCIE_CFG_RDATA 0x48c
84 #define APP_CFG_REQ BIT(0)
85 #define APP_CPL_STATUS GENMASK(7, 5)
87 #define CFG_WRRD_TYPE_0 4
91 #define CFG_DW0_LENGTH(length) ((length) & GENMASK(9, 0))
92 #define CFG_DW0_TYPE(type) (((type) << 24) & GENMASK(28, 24))
93 #define CFG_DW0_FMT(fmt) (((fmt) << 29) & GENMASK(31, 29))
94 #define CFG_DW2_REGN(regn) ((regn) & GENMASK(11, 2))
95 #define CFG_DW2_FUN(fun) (((fun) << 16) & GENMASK(18, 16))
96 #define CFG_DW2_DEV(dev) (((dev) << 19) & GENMASK(23, 19))
97 #define CFG_DW2_BUS(bus) (((bus) << 24) & GENMASK(31, 24))
98 #define CFG_HEADER_DW0(type, fmt) \
99 (CFG_DW0_LENGTH(1) | CFG_DW0_TYPE(type) | CFG_DW0_FMT(fmt))
100 #define CFG_HEADER_DW1(where, size) \
101 (GENMASK(((size) - 1), 0) << ((where) & 0x3))
102 #define CFG_HEADER_DW2(regn, fun, dev, bus) \
103 (CFG_DW2_REGN(regn) | CFG_DW2_FUN(fun) | \
104 CFG_DW2_DEV(dev) | CFG_DW2_BUS(bus))
106 #define PCIE_RST_CTRL 0x510
107 #define PCIE_PHY_RSTB BIT(0)
108 #define PCIE_PIPE_SRSTB BIT(1)
109 #define PCIE_MAC_SRSTB BIT(2)
110 #define PCIE_CRSTB BIT(3)
111 #define PCIE_PERSTB BIT(8)
112 #define PCIE_LINKDOWN_RST_EN GENMASK(15, 13)
113 #define PCIE_LINK_STATUS_V2 0x804
114 #define PCIE_PORT_LINKUP_V2 BIT(11)
116 #define PCI_VENDOR_ID_MEDIATEK 0x14c3
118 enum MTK_PCIE_GEN {PCIE_V1, PCIE_V2, PCIE_V3};
120 struct mtk_pcie_port {
122 struct list_head list;
123 struct mtk_pcie *pcie;
124 struct reset_ctl reset;
139 struct list_head ports;
142 static int mtk_pcie_config_address(const struct udevice *udev, pci_dev_t bdf,
143 uint offset, void **paddress)
145 struct mtk_pcie *pcie = dev_get_priv(udev);
148 val = PCI_CONF1_EXT_ADDRESS(PCI_BUS(bdf), PCI_DEV(bdf),
149 PCI_FUNC(bdf), offset) & ~PCI_CONF1_ENABLE;
150 writel(val, pcie->base + PCIE_CFG_ADDR);
151 *paddress = pcie->base + PCIE_CFG_DATA + (offset & 3);
156 static int mtk_pcie_read_config(const struct udevice *bus, pci_dev_t bdf,
157 uint offset, ulong *valuep,
158 enum pci_size_t size)
160 return pci_generic_mmap_read_config(bus, mtk_pcie_config_address,
161 bdf, offset, valuep, size);
164 static int mtk_pcie_write_config(struct udevice *bus, pci_dev_t bdf,
165 uint offset, ulong value,
166 enum pci_size_t size)
168 return pci_generic_mmap_write_config(bus, mtk_pcie_config_address,
169 bdf, offset, value, size);
172 static const struct dm_pci_ops mtk_pcie_ops = {
173 .read_config = mtk_pcie_read_config,
174 .write_config = mtk_pcie_write_config,
177 static int mtk_pcie_check_cfg_cpld(struct mtk_pcie_port *port)
182 err = readl_poll_timeout(port->base + PCIE_APP_TLP_REQ, val,
183 !(val & APP_CFG_REQ), 100 * 1000);
187 if (readl(port->base + PCIE_APP_TLP_REQ) & APP_CPL_STATUS)
193 static int mtk_pcie_hw_rd_cfg(struct mtk_pcie_port *port, u32 bus, pci_dev_t devfn,
194 int where, int size, ulong *val)
198 writel(CFG_HEADER_DW0(CFG_WRRD_TYPE_0, CFG_RD_FMT),
199 port->base + PCIE_CFG_HEADER0);
200 writel(CFG_HEADER_DW1(where, size), port->base + PCIE_CFG_HEADER1);
201 writel(CFG_HEADER_DW2(where, PCI_FUNC(devfn), PCI_DEV(devfn), bus),
202 port->base + PCIE_CFG_HEADER2);
204 /* Trigger h/w to transmit Cfgrd TLP */
205 tmp = readl(port->base + PCIE_APP_TLP_REQ);
207 writel(tmp, port->base + PCIE_APP_TLP_REQ);
209 /* Check completion status */
210 if (mtk_pcie_check_cfg_cpld(port))
213 /* Read cpld payload of Cfgrd */
214 *val = readl(port->base + PCIE_CFG_RDATA);
217 *val = (*val >> (8 * (where & 3))) & 0xff;
219 *val = (*val >> (8 * (where & 3))) & 0xffff;
224 static int mtk_pcie_hw_wr_cfg(struct mtk_pcie_port *port, u32 bus, pci_dev_t devfn,
225 int where, int size, u32 val)
227 /* Write PCIe configuration transaction header for Cfgwr */
228 writel(CFG_HEADER_DW0(CFG_WRRD_TYPE_0, CFG_WR_FMT),
229 port->base + PCIE_CFG_HEADER0);
230 writel(CFG_HEADER_DW1(where, size), port->base + PCIE_CFG_HEADER1);
231 writel(CFG_HEADER_DW2(where, PCI_FUNC(devfn), PCI_DEV(devfn), bus),
232 port->base + PCIE_CFG_HEADER2);
234 /* Write Cfgwr data */
235 val = val << 8 * (where & 3);
236 writel(val, port->base + PCIE_CFG_WDATA);
238 /* Trigger h/w to transmit Cfgwr TLP */
239 val = readl(port->base + PCIE_APP_TLP_REQ);
241 writel(val, port->base + PCIE_APP_TLP_REQ);
243 /* Check completion status */
244 return mtk_pcie_check_cfg_cpld(port);
247 static struct mtk_pcie_port *mtk_pcie_find_port(const struct udevice *bus,
250 struct mtk_pcie *pcie = dev_get_priv(bus);
251 struct mtk_pcie_port *port;
253 struct pci_child_plat *pplat = NULL;
256 if (PCI_BUS(bdf) != 0) {
257 ret = pci_get_bus(PCI_BUS(bdf), &dev);
259 debug("No such device,ret = %d\n", ret);
263 while (dev_seq(dev->parent) != 0)
266 pplat = dev_get_parent_plat(dev);
269 list_for_each_entry(port, &pcie->ports, list) {
270 if ((PCI_BUS(bdf) == 0) && (PCI_DEV(bdf) == port->slot))
273 if (PCI_BUS(bdf) != 0 && PCI_DEV(bdf) == 0 &&
274 PCI_DEV(pplat->devfn) == port->slot)
281 static int mtk_pcie_config_read(const struct udevice *bus, pci_dev_t bdf,
282 uint offset, ulong *valuep,
283 enum pci_size_t size)
285 struct mtk_pcie_port *port;
288 port = mtk_pcie_find_port(bus, bdf);
290 *valuep = pci_get_ff(size);
294 ret = mtk_pcie_hw_rd_cfg(port, PCI_BUS(bdf), bdf, offset, (1 << size), valuep);
296 *valuep = pci_get_ff(size);
301 static int mtk_pcie_config_write(struct udevice *bus, pci_dev_t bdf,
302 uint offset, ulong value,
303 enum pci_size_t size)
305 struct mtk_pcie_port *port;
307 port = mtk_pcie_find_port(bus, bdf);
311 /* Do not modify RC bar 0/1. */
312 if (PCI_BUS(bdf) == 0 && (offset == 0x10 || offset == 0x14))
315 return mtk_pcie_hw_wr_cfg(port, PCI_BUS(bdf), bdf, offset, (1 << size), value);
318 static const struct dm_pci_ops mtk_pcie_ops_v2 = {
319 .read_config = mtk_pcie_config_read,
320 .write_config = mtk_pcie_config_write,
323 static void mtk_pcie_port_free(struct mtk_pcie_port *port)
325 list_del(&port->list);
329 static int mtk_pcie_startup_port(struct mtk_pcie_port *port)
331 struct mtk_pcie *pcie = port->pcie;
335 /* assert port PERST_N */
336 setbits_le32(pcie->base + PCIE_SYS_CFG, PCIE_PORT_PERST(port->slot));
337 /* de-assert port PERST_N */
338 clrbits_le32(pcie->base + PCIE_SYS_CFG, PCIE_PORT_PERST(port->slot));
340 /* 100ms timeout value should be enough for Gen1/2 training */
341 err = readl_poll_timeout(port->base + PCIE_LINK_STATUS, val,
342 !!(val & PCIE_PORT_LINKUP), 100000);
346 /* disable interrupt */
347 clrbits_le32(pcie->base + PCIE_INT_ENABLE,
348 PCIE_PORT_INT_EN(port->slot));
350 /* map to all DDR region. We need to set it before cfg operation. */
351 writel(PCIE_BAR_MAP_MAX | PCIE_BAR_ENABLE,
352 port->base + PCIE_BAR0_SETUP);
354 /* configure class code and revision ID */
355 writel(PCIE_CLASS_CODE | PCIE_REVISION_ID, port->base + PCIE_CLASS);
357 /* configure FC credit */
358 val = PCI_CONF1_EXT_ADDRESS(0, port->slot, 0, PCIE_FC_CREDIT) & ~PCI_CONF1_ENABLE;
359 writel(val, pcie->base + PCIE_CFG_ADDR);
360 clrsetbits_le32(pcie->base + PCIE_CFG_DATA, PCIE_FC_CREDIT_MASK,
361 PCIE_FC_CREDIT_VAL(0x806c));
363 /* configure RC FTS number to 250 when it leaves L0s */
364 val = PCI_CONF1_EXT_ADDRESS(0, port->slot, 0, PCIE_FTS_NUM) & ~PCI_CONF1_ENABLE;
365 writel(val, pcie->base + PCIE_CFG_ADDR);
366 clrsetbits_le32(pcie->base + PCIE_CFG_DATA, PCIE_FTS_NUM_MASK,
367 PCIE_FTS_NUM_L0(0x50));
372 static int mtk_pcie_startup_port_v2(struct mtk_pcie_port *port)
374 struct mtk_pcie *pcie = port->pcie;
375 struct udevice *dev = pcie->priv;
376 struct pci_region *pci_mem;
380 /* MT7622/MT7629 platforms need to enable LTSSM and ASPM from PCIe subsys */
382 val = readl(pcie->base + PCIE_SYS_CFG_V2);
383 val |= PCIE_CSR_LTSSM_EN(port->slot) |
384 PCIE_CSR_ASPM_L1_EN(port->slot);
385 writel(val, pcie->base + PCIE_SYS_CFG_V2);
388 /* Assert all reset signals */
389 writel(0, port->base + PCIE_RST_CTRL);
392 * Enable PCIe link down reset, if link status changed from link up to
393 * link down, this will reset MAC control registers and configuration
396 writel(PCIE_LINKDOWN_RST_EN, port->base + PCIE_RST_CTRL);
399 /* De-assert PHY, PE, PIPE, MAC and configuration reset */
400 val = readl(port->base + PCIE_RST_CTRL);
401 val |= PCIE_PHY_RSTB | PCIE_PIPE_SRSTB | PCIE_MAC_SRSTB | PCIE_CRSTB;
402 writel(val, port->base + PCIE_RST_CTRL);
406 writel(val, port->base + PCIE_RST_CTRL);
408 /* Set up vendor ID and class code */
409 val = PCI_VENDOR_ID_MEDIATEK;
410 writew(val, port->base + PCIE_CONF_VEND_ID);
412 val = PCI_CLASS_BRIDGE_PCI;
413 writew(val, port->base + PCIE_CONF_CLASS_ID);
415 /* 100ms timeout value should be enough for Gen1/2 training */
416 err = readl_poll_timeout(port->base + PCIE_LINK_STATUS_V2, val,
417 !!(val & PCIE_PORT_LINKUP_V2),
422 pci_get_regions(dev, NULL, &pci_mem, NULL);
424 /* Set AHB to PCIe translation windows */
425 val = lower_32_bits(pci_mem->bus_start) |
426 AHB2PCIE_SIZE(fls(pci_mem->size) - 1);
427 writel(val, port->base + PCIE_AHB_TRANS_BASE0_L);
429 val = upper_32_bits(pci_mem->bus_start);
430 writel(val, port->base + PCIE_AHB_TRANS_BASE0_H);
432 /* Set PCIe to AXI translation memory space.*/
433 val = PCIE2AHB_SIZE | WIN_ENABLE;
434 writel(val, port->base + PCIE_AXI_WINDOW0);
439 static void mtk_pcie_enable_port(struct mtk_pcie_port *port)
443 err = clk_enable(&port->sys_ck);
447 err = reset_assert(&port->reset);
451 err = reset_deassert(&port->reset);
455 err = generic_phy_init(&port->phy);
459 err = generic_phy_power_on(&port->phy);
463 if (!mtk_pcie_startup_port(port))
466 pr_err("Port%d link down\n", port->slot);
468 generic_phy_power_off(&port->phy);
470 generic_phy_exit(&port->phy);
473 clk_disable(&port->sys_ck);
475 mtk_pcie_port_free(port);
478 static void mtk_pcie_enable_port_v2(struct mtk_pcie_port *port)
482 err = clk_enable(&port->sys_ck);
484 debug("clk_enable(sys_ck) failed: %d\n", err);
488 err = clk_enable(&port->ahb_ck);
490 debug("clk_enable(ahb_ck) failed: %d\n", err);
494 err = clk_enable(&port->aux_ck);
496 debug("clk_enable(aux_ck) failed: %d\n", err);
500 err = clk_enable(&port->axi_ck);
502 debug("clk_enable(axi_ck) failed: %d\n", err);
506 err = clk_enable(&port->obff_ck);
508 debug("clk_enable(obff_ck) failed: %d\n", err);
512 err = clk_enable(&port->pipe_ck);
514 debug("clk_enable(pipe_ck) failed: %d\n", err);
518 err = mtk_pcie_startup_port_v2(port);
522 pr_err("Port%d link down\n", port->slot);
524 mtk_pcie_port_free(port);
527 static int mtk_pcie_parse_port(struct udevice *dev, u32 slot)
529 struct mtk_pcie *pcie = dev_get_priv(dev);
530 struct mtk_pcie_port *port;
534 port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL);
538 snprintf(name, sizeof(name), "port%d", slot);
539 port->base = dev_remap_addr_name(dev, name);
543 snprintf(name, sizeof(name), "sys_ck%d", slot);
544 err = clk_get_by_name(dev, name, &port->sys_ck);
548 err = reset_get_by_index(dev, slot, &port->reset);
552 err = generic_phy_get_by_index(dev, slot, &port->phy);
559 INIT_LIST_HEAD(&port->list);
560 list_add_tail(&port->list, &pcie->ports);
565 static int mtk_pcie_parse_port_v2(struct udevice *dev, u32 slot)
567 struct mtk_pcie *pcie = dev_get_priv(dev);
568 struct mtk_pcie_port *port;
572 port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL);
576 snprintf(name, sizeof(name), "port%d", slot);
577 port->base = dev_remap_addr_name(dev, name);
579 debug("failed to map port%d base\n", slot);
583 snprintf(name, sizeof(name), "sys_ck%d", slot);
584 err = clk_get_by_name(dev, name, &port->sys_ck);
586 debug("clk_get_by_name(sys_ck) failed: %d\n", err);
590 snprintf(name, sizeof(name), "ahb_ck%d", slot);
591 err = clk_get_by_name(dev, name, &port->ahb_ck);
593 debug("clk_get_by_name(ahb_ck) failed: %d\n", err);
597 snprintf(name, sizeof(name), "aux_ck%d", slot);
598 err = clk_get_by_name(dev, name, &port->aux_ck);
600 debug("clk_get_by_name(aux_ck) failed: %d\n", err);
604 snprintf(name, sizeof(name), "axi_ck%d", slot);
605 err = clk_get_by_name(dev, name, &port->axi_ck);
607 debug("clk_get_by_name(axi_ck) failed: %d\n", err);
611 snprintf(name, sizeof(name), "obff_ck%d", slot);
612 err = clk_get_by_name(dev, name, &port->obff_ck);
614 debug("clk_get_by_name(obff_ck) failed: %d\n", err);
618 snprintf(name, sizeof(name), "pipe_ck%d", slot);
619 err = clk_get_by_name(dev, name, &port->pipe_ck);
621 debug("clk_get_by_name(pipe_ck) failed: %d\n", err);
628 INIT_LIST_HEAD(&port->list);
629 list_add_tail(&port->list, &pcie->ports);
634 static int mtk_pcie_probe(struct udevice *dev)
636 struct mtk_pcie *pcie = dev_get_priv(dev);
637 struct mtk_pcie_port *port, *tmp;
641 INIT_LIST_HEAD(&pcie->ports);
643 pcie->base = dev_remap_addr_name(dev, "subsys");
647 err = clk_get_by_name(dev, "free_ck", &pcie->free_ck);
651 /* enable top level clock */
652 err = clk_enable(&pcie->free_ck);
656 dev_for_each_subnode(subnode, dev) {
657 struct fdt_pci_addr addr;
660 if (!ofnode_is_available(subnode))
663 err = ofnode_read_pci_addr(subnode, 0, "reg", &addr);
667 slot = PCI_DEV(addr.phys_hi);
669 err = mtk_pcie_parse_port(dev, slot);
674 /* enable each port, and then check link status */
675 list_for_each_entry_safe(port, tmp, &pcie->ports, list)
676 mtk_pcie_enable_port(port);
681 static int mtk_pcie_probe_v2(struct udevice *dev)
683 struct mtk_pcie *pcie = dev_get_priv(dev);
684 struct mtk_pcie_port *port, *tmp;
685 struct fdt_pci_addr addr;
690 INIT_LIST_HEAD(&pcie->ports);
692 pcie->base = dev_remap_addr_name(dev, "subsys");
698 dev_for_each_subnode(subnode, dev) {
699 if (!ofnode_is_available(subnode))
702 err = ofnode_read_pci_addr(subnode, 0, "reg", &addr);
706 slot = PCI_DEV(addr.phys_hi);
707 err = mtk_pcie_parse_port_v2(dev, slot);
712 /* enable each port, and then check link status */
713 list_for_each_entry_safe(port, tmp, &pcie->ports, list)
714 mtk_pcie_enable_port_v2(port);
719 static const struct udevice_id mtk_pcie_ids[] = {
720 { .compatible = "mediatek,mt7623-pcie", PCIE_V1},
724 U_BOOT_DRIVER(pcie_mediatek_v1) = {
725 .name = "pcie_mediatek_v1",
727 .of_match = mtk_pcie_ids,
728 .ops = &mtk_pcie_ops,
729 .probe = mtk_pcie_probe,
730 .priv_auto = sizeof(struct mtk_pcie),
733 static const struct udevice_id mtk_pcie_ids_v2[] = {
734 { .compatible = "mediatek,mt7622-pcie", PCIE_V2},
738 U_BOOT_DRIVER(pcie_mediatek_v2) = {
739 .name = "pcie_mediatek_v2",
741 .of_match = mtk_pcie_ids_v2,
742 .ops = &mtk_pcie_ops_v2,
743 .probe = mtk_pcie_probe_v2,
744 .priv_auto = sizeof(struct mtk_pcie),