1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Rockchip DesignWare based PCIe host controller driver 4 * 5 * Copyright (c) 2021 Rockchip, Inc. 6 */ 7 8 #include <common.h> 9 #include <clk.h> 10 #include <dm.h> 11 #include <generic-phy.h> 12 #include <pci.h> 13 #include <power-domain.h> 14 #include <power/regulator.h> 15 #include <reset.h> 16 #include <syscon.h> 17 #include <asm/io.h> 18 #include <asm-generic/gpio.h> 19 #include <asm/arch-rockchip/clock.h> 20 #include <linux/iopoll.h> 21 22 DECLARE_GLOBAL_DATA_PTR; 23 24 struct rk_pcie { 25 struct udevice *dev; 26 struct udevice *vpcie3v3; 27 void *dbi_base; 28 void *apb_base; 29 void *cfg_base; 30 fdt_size_t cfg_size; 31 struct phy phy; 32 struct clk_bulk clks; 33 int first_busno; 34 struct reset_ctl_bulk rsts; 35 struct gpio_desc rst_gpio; 36 struct pci_region io; 37 struct pci_region mem; 38 bool is_bifurcation; 39 u32 gen; 40 }; 41 42 enum { 43 PCIBIOS_SUCCESSFUL = 0x0000, 44 PCIBIOS_UNSUPPORTED = -ENODEV, 45 PCIBIOS_NODEV = -ENODEV, 46 }; 47 48 #define msleep(a) udelay((a) * 1000) 49 50 /* Parameters for the waiting for iATU enabled routine */ 51 #define PCIE_CLIENT_GENERAL_DEBUG 0x104 52 #define PCIE_CLIENT_HOT_RESET_CTRL 0x180 53 #define PCIE_LTSSM_ENABLE_ENHANCE BIT(4) 54 #define PCIE_CLIENT_LTSSM_STATUS 0x300 55 #define SMLH_LINKUP BIT(16) 56 #define RDLH_LINKUP BIT(17) 57 #define PCIE_CLIENT_DBG_FIFO_MODE_CON 0x310 58 #define PCIE_CLIENT_DBG_FIFO_PTN_HIT_D0 0x320 59 #define PCIE_CLIENT_DBG_FIFO_PTN_HIT_D1 0x324 60 #define PCIE_CLIENT_DBG_FIFO_TRN_HIT_D0 0x328 61 #define PCIE_CLIENT_DBG_FIFO_TRN_HIT_D1 0x32c 62 #define PCIE_CLIENT_DBG_FIFO_STATUS 0x350 63 #define PCIE_CLIENT_DBG_TRANSITION_DATA 0xffff0000 64 #define PCIE_CLIENT_DBF_EN 0xffff0003 65 #define RK_PCIE_DBG 0 66 67 /* PCI DBICS registers */ 68 #define PCIE_LINK_STATUS_REG 0x80 69 #define PCIE_LINK_STATUS_SPEED_OFF 16 70 #define PCIE_LINK_STATUS_SPEED_MASK (0xf << PCIE_LINK_STATUS_SPEED_OFF) 71 #define PCIE_LINK_STATUS_WIDTH_OFF 20 72 #define PCIE_LINK_STATUS_WIDTH_MASK (0xf << PCIE_LINK_STATUS_WIDTH_OFF) 73 74 #define PCIE_LINK_CAPABILITY 0x7c 75 #define PCIE_LINK_CTL_2 0xa0 76 #define TARGET_LINK_SPEED_MASK 0xf 77 #define LINK_SPEED_GEN_1 0x1 78 #define LINK_SPEED_GEN_2 0x2 79 #define LINK_SPEED_GEN_3 0x3 80 81 #define PCIE_MISC_CONTROL_1_OFF 0x8bc 82 #define PCIE_DBI_RO_WR_EN BIT(0) 83 84 #define PCIE_LINK_WIDTH_SPEED_CONTROL 0x80c 85 #define PORT_LOGIC_SPEED_CHANGE BIT(17) 86 87 /* 88 * iATU Unroll-specific register definitions 89 * From 4.80 core version the address translation will be made by unroll. 90 * The registers are offset from atu_base 91 */ 92 #define PCIE_ATU_UNR_REGION_CTRL1 0x00 93 #define PCIE_ATU_UNR_REGION_CTRL2 0x04 94 #define PCIE_ATU_UNR_LOWER_BASE 0x08 95 #define PCIE_ATU_UNR_UPPER_BASE 0x0c 96 #define PCIE_ATU_UNR_LIMIT 0x10 97 #define PCIE_ATU_UNR_LOWER_TARGET 0x14 98 #define PCIE_ATU_UNR_UPPER_TARGET 0x18 99 100 #define PCIE_ATU_REGION_INDEX1 (0x1 << 0) 101 #define PCIE_ATU_REGION_INDEX0 (0x0 << 0) 102 #define PCIE_ATU_TYPE_MEM (0x0 << 0) 103 #define PCIE_ATU_TYPE_IO (0x2 << 0) 104 #define PCIE_ATU_TYPE_CFG0 (0x4 << 0) 105 #define PCIE_ATU_TYPE_CFG1 (0x5 << 0) 106 #define PCIE_ATU_ENABLE (0x1 << 31) 107 #define PCIE_ATU_BAR_MODE_ENABLE (0x1 << 30) 108 #define PCIE_ATU_BUS(x) (((x) & 0xff) << 24) 109 #define PCIE_ATU_DEV(x) (((x) & 0x1f) << 19) 110 #define PCIE_ATU_FUNC(x) (((x) & 0x7) << 16) 111 112 /* Register address builder */ 113 #define PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(region) \ 114 ((0x3 << 20) | ((region) << 9)) 115 #define PCIE_GET_ATU_INB_UNR_REG_OFFSET(region) \ 116 ((0x3 << 20) | ((region) << 9) | (0x1 << 8)) 117 118 /* Parameters for the waiting for iATU enabled routine */ 119 #define LINK_WAIT_MAX_IATU_RETRIES 5 120 #define LINK_WAIT_IATU 10000 121 122 static int rk_pcie_read(void __iomem *addr, int size, u32 *val) 123 { 124 if ((uintptr_t)addr & (size - 1)) { 125 *val = 0; 126 return PCIBIOS_UNSUPPORTED; 127 } 128 129 if (size == 4) { 130 *val = readl(addr); 131 } else if (size == 2) { 132 *val = readw(addr); 133 } else if (size == 1) { 134 *val = readb(addr); 135 } else { 136 *val = 0; 137 return PCIBIOS_NODEV; 138 } 139 140 return PCIBIOS_SUCCESSFUL; 141 } 142 143 static int rk_pcie_write(void __iomem *addr, int size, u32 val) 144 { 145 if ((uintptr_t)addr & (size - 1)) 146 return PCIBIOS_UNSUPPORTED; 147 148 if (size == 4) 149 writel(val, addr); 150 else if (size == 2) 151 writew(val, addr); 152 else if (size == 1) 153 writeb(val, addr); 154 else 155 return PCIBIOS_NODEV; 156 157 return PCIBIOS_SUCCESSFUL; 158 } 159 160 static u32 __rk_pcie_read_apb(struct rk_pcie *rk_pcie, void __iomem *base, 161 u32 reg, size_t size) 162 { 163 int ret; 164 u32 val; 165 166 ret = rk_pcie_read(base + reg, size, &val); 167 if (ret) 168 dev_err(rk_pcie->pci->dev, "Read APB address failed\n"); 169 170 return val; 171 } 172 173 static void __rk_pcie_write_apb(struct rk_pcie *rk_pcie, void __iomem *base, 174 u32 reg, size_t size, u32 val) 175 { 176 int ret; 177 178 ret = rk_pcie_write(base + reg, size, val); 179 if (ret) 180 dev_err(rk_pcie->pci->dev, "Write APB address failed\n"); 181 } 182 183 static inline u32 rk_pcie_readl_apb(struct rk_pcie *rk_pcie, u32 reg) 184 { 185 return __rk_pcie_read_apb(rk_pcie, rk_pcie->apb_base, reg, 0x4); 186 } 187 188 static inline void rk_pcie_writel_apb(struct rk_pcie *rk_pcie, u32 reg, 189 u32 val) 190 { 191 __rk_pcie_write_apb(rk_pcie, rk_pcie->apb_base, reg, 0x4, val); 192 } 193 194 static int rk_pcie_get_link_speed(struct rk_pcie *rk_pcie) 195 { 196 return (readl(rk_pcie->dbi_base + PCIE_LINK_STATUS_REG) & 197 PCIE_LINK_STATUS_SPEED_MASK) >> PCIE_LINK_STATUS_SPEED_OFF; 198 } 199 200 static int rk_pcie_get_link_width(struct rk_pcie *rk_pcie) 201 { 202 return (readl(rk_pcie->dbi_base + PCIE_LINK_STATUS_REG) & 203 PCIE_LINK_STATUS_WIDTH_MASK) >> PCIE_LINK_STATUS_WIDTH_OFF; 204 } 205 206 static void rk_pcie_writel_ob_unroll(struct rk_pcie *rk_pcie, u32 index, 207 u32 reg, u32 val) 208 { 209 u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index); 210 void __iomem *base = rk_pcie->dbi_base; 211 212 writel(val, base + offset + reg); 213 } 214 215 static u32 rk_pcie_readl_ob_unroll(struct rk_pcie *rk_pcie, u32 index, u32 reg) 216 { 217 u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index); 218 void __iomem *base = rk_pcie->dbi_base; 219 220 return readl(base + offset + reg); 221 } 222 223 static inline void rk_pcie_dbi_write_enable(struct rk_pcie *rk_pcie, bool en) 224 { 225 u32 val; 226 227 val = readl(rk_pcie->dbi_base + PCIE_MISC_CONTROL_1_OFF); 228 229 if (en) 230 val |= PCIE_DBI_RO_WR_EN; 231 else 232 val &= ~PCIE_DBI_RO_WR_EN; 233 writel(val, rk_pcie->dbi_base + PCIE_MISC_CONTROL_1_OFF); 234 } 235 236 static void rk_pcie_setup_host(struct rk_pcie *rk_pcie) 237 { 238 u32 val; 239 240 rk_pcie_dbi_write_enable(rk_pcie, true); 241 242 /* setup RC BARs */ 243 writel(PCI_BASE_ADDRESS_MEM_TYPE_64, 244 rk_pcie->dbi_base + PCI_BASE_ADDRESS_0); 245 writel(0x0, rk_pcie->dbi_base + PCI_BASE_ADDRESS_1); 246 247 /* setup interrupt pins */ 248 val = readl(rk_pcie->dbi_base + PCI_INTERRUPT_LINE); 249 val &= 0xffff00ff; 250 val |= 0x00000100; 251 writel(val, rk_pcie->dbi_base + PCI_INTERRUPT_LINE); 252 253 /* setup bus numbers */ 254 val = readl(rk_pcie->dbi_base + PCI_PRIMARY_BUS); 255 val &= 0xff000000; 256 val |= 0x00ff0100; 257 writel(val, rk_pcie->dbi_base + PCI_PRIMARY_BUS); 258 259 val = readl(rk_pcie->dbi_base + PCI_PRIMARY_BUS); 260 261 /* setup command register */ 262 val = readl(rk_pcie->dbi_base + PCI_COMMAND); 263 val &= 0xffff0000; 264 val |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY | 265 PCI_COMMAND_MASTER | PCI_COMMAND_SERR; 266 writel(val, rk_pcie->dbi_base + PCI_COMMAND); 267 268 /* program correct class for RC */ 269 writew(PCI_CLASS_BRIDGE_PCI, rk_pcie->dbi_base + PCI_CLASS_DEVICE); 270 /* Better disable write permission right after the update */ 271 272 val = readl(rk_pcie->dbi_base + PCIE_LINK_WIDTH_SPEED_CONTROL); 273 val |= PORT_LOGIC_SPEED_CHANGE; 274 writel(val, rk_pcie->dbi_base + PCIE_LINK_WIDTH_SPEED_CONTROL); 275 276 rk_pcie_dbi_write_enable(rk_pcie, false); 277 } 278 279 static void rk_pcie_configure(struct rk_pcie *pci, u32 cap_speed) 280 { 281 u32 val; 282 283 rk_pcie_dbi_write_enable(pci, true); 284 285 val = readl(pci->dbi_base + PCIE_LINK_CAPABILITY); 286 val &= ~TARGET_LINK_SPEED_MASK; 287 val |= cap_speed; 288 writel(val, pci->dbi_base + PCIE_LINK_CAPABILITY); 289 290 val = readl(pci->dbi_base + PCIE_LINK_CTL_2); 291 val &= ~TARGET_LINK_SPEED_MASK; 292 val |= cap_speed; 293 writel(val, pci->dbi_base + PCIE_LINK_CTL_2); 294 295 rk_pcie_dbi_write_enable(pci, false); 296 } 297 298 static void rk_pcie_prog_outbound_atu_unroll(struct rk_pcie *pci, int index, 299 int type, u64 cpu_addr, 300 u64 pci_addr, u32 size) 301 { 302 u32 retries, val; 303 304 dev_dbg(pci->dev, "ATU programmed with: index: %d, type: %d, cpu addr: %8llx, pci addr: %8llx, size: %8x\n", 305 index, type, cpu_addr, pci_addr, size); 306 307 rk_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_LOWER_BASE, 308 lower_32_bits(cpu_addr)); 309 rk_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_UPPER_BASE, 310 upper_32_bits(cpu_addr)); 311 rk_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_LIMIT, 312 lower_32_bits(cpu_addr + size - 1)); 313 rk_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_LOWER_TARGET, 314 lower_32_bits(pci_addr)); 315 rk_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_UPPER_TARGET, 316 upper_32_bits(pci_addr)); 317 rk_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL1, 318 type); 319 rk_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL2, 320 PCIE_ATU_ENABLE); 321 322 /* 323 * Make sure ATU enable takes effect before any subsequent config 324 * and I/O accesses. 325 */ 326 for (retries = 0; retries < LINK_WAIT_MAX_IATU_RETRIES; retries++) { 327 val = rk_pcie_readl_ob_unroll(pci, index, 328 PCIE_ATU_UNR_REGION_CTRL2); 329 if (val & PCIE_ATU_ENABLE) 330 return; 331 332 udelay(LINK_WAIT_IATU); 333 } 334 dev_err(pci->dev, "outbound iATU is not being enabled\n"); 335 } 336 337 static int rk_pcie_addr_valid(pci_dev_t d, int first_busno) 338 { 339 if ((PCI_BUS(d) == first_busno) && (PCI_DEV(d) > 0)) 340 return 0; 341 if ((PCI_BUS(d) == first_busno + 1) && (PCI_DEV(d) > 0)) 342 return 0; 343 344 return 1; 345 } 346 347 static uintptr_t set_cfg_address(struct rk_pcie *pcie, 348 pci_dev_t d, uint where) 349 { 350 int bus = PCI_BUS(d) - pcie->first_busno; 351 uintptr_t va_address; 352 u32 atu_type; 353 354 /* Use dbi_base for own configuration read and write */ 355 if (!bus) { 356 va_address = (uintptr_t)pcie->dbi_base; 357 goto out; 358 } 359 360 if (bus == 1) 361 /* 362 * For local bus whose primary bus number is root bridge, 363 * change TLP Type field to 4. 364 */ 365 atu_type = PCIE_ATU_TYPE_CFG0; 366 else 367 /* Otherwise, change TLP Type field to 5. */ 368 atu_type = PCIE_ATU_TYPE_CFG1; 369 370 /* 371 * Not accessing root port configuration space? 372 * Region #0 is used for Outbound CFG space access. 373 * Direction = Outbound 374 * Region Index = 0 375 */ 376 d = PCI_MASK_BUS(d); 377 d = PCI_ADD_BUS(bus, d); 378 rk_pcie_prog_outbound_atu_unroll(pcie, PCIE_ATU_REGION_INDEX1, 379 atu_type, (u64)pcie->cfg_base, 380 d << 8, pcie->cfg_size); 381 382 va_address = (uintptr_t)pcie->cfg_base; 383 384 out: 385 va_address += where & ~0x3; 386 387 return va_address; 388 } 389 390 static int rockchip_pcie_rd_conf(struct udevice *bus, pci_dev_t bdf, 391 uint offset, ulong *valuep, 392 enum pci_size_t size) 393 { 394 struct rk_pcie *pcie = dev_get_priv(bus); 395 uintptr_t va_address; 396 ulong value; 397 398 debug("PCIE CFG read: bdf=%2x:%2x:%2x\n", 399 PCI_BUS(bdf), PCI_DEV(bdf), PCI_FUNC(bdf)); 400 401 if (!rk_pcie_addr_valid(bdf, pcie->first_busno)) { 402 debug("- out of range\n"); 403 *valuep = pci_get_ff(size); 404 return 0; 405 } 406 407 va_address = set_cfg_address(pcie, bdf, offset); 408 409 value = readl(va_address); 410 411 debug("(addr,val)=(0x%04x, 0x%08lx)\n", offset, value); 412 *valuep = pci_conv_32_to_size(value, offset, size); 413 414 rk_pcie_prog_outbound_atu_unroll(pcie, PCIE_ATU_REGION_INDEX1, 415 PCIE_ATU_TYPE_IO, pcie->io.phys_start, 416 pcie->io.bus_start, pcie->io.size); 417 418 return 0; 419 } 420 421 static int rockchip_pcie_wr_conf(struct udevice *bus, pci_dev_t bdf, 422 uint offset, ulong value, 423 enum pci_size_t size) 424 { 425 struct rk_pcie *pcie = dev_get_priv(bus); 426 uintptr_t va_address; 427 ulong old; 428 429 debug("PCIE CFG write: (b,d,f)=(%2d,%2d,%2d)\n", 430 PCI_BUS(bdf), PCI_DEV(bdf), PCI_FUNC(bdf)); 431 debug("(addr,val)=(0x%04x, 0x%08lx)\n", offset, value); 432 433 if (!rk_pcie_addr_valid(bdf, pcie->first_busno)) { 434 debug("- out of range\n"); 435 return 0; 436 } 437 438 va_address = set_cfg_address(pcie, bdf, offset); 439 440 old = readl(va_address); 441 value = pci_conv_size_to_32(old, value, offset, size); 442 writel(value, va_address); 443 444 rk_pcie_prog_outbound_atu_unroll(pcie, PCIE_ATU_REGION_INDEX1, 445 PCIE_ATU_TYPE_IO, pcie->io.phys_start, 446 pcie->io.bus_start, pcie->io.size); 447 448 return 0; 449 } 450 451 static void rk_pcie_enable_debug(struct rk_pcie *rk_pcie) 452 { 453 #if RK_PCIE_DBG 454 rk_pcie_writel_apb(rk_pcie, PCIE_CLIENT_DBG_FIFO_PTN_HIT_D0, 455 PCIE_CLIENT_DBG_TRANSITION_DATA); 456 rk_pcie_writel_apb(rk_pcie, PCIE_CLIENT_DBG_FIFO_PTN_HIT_D1, 457 PCIE_CLIENT_DBG_TRANSITION_DATA); 458 rk_pcie_writel_apb(rk_pcie, PCIE_CLIENT_DBG_FIFO_TRN_HIT_D0, 459 PCIE_CLIENT_DBG_TRANSITION_DATA); 460 rk_pcie_writel_apb(rk_pcie, PCIE_CLIENT_DBG_FIFO_TRN_HIT_D1, 461 PCIE_CLIENT_DBG_TRANSITION_DATA); 462 rk_pcie_writel_apb(rk_pcie, PCIE_CLIENT_DBG_FIFO_MODE_CON, 463 PCIE_CLIENT_DBF_EN); 464 #endif 465 } 466 467 static void rk_pcie_debug_dump(struct rk_pcie *rk_pcie) 468 { 469 #if RK_PCIE_DBG 470 u32 loop; 471 472 dev_info(rk_pcie->dev, "ltssm = 0x%x\n", 473 rk_pcie_readl_apb(rk_pcie, PCIE_CLIENT_LTSSM_STATUS)); 474 for (loop = 0; loop < 64; loop++) 475 dev_info(rk_pcie->dev, "fifo_status = 0x%x\n", 476 rk_pcie_readl_apb(rk_pcie, PCIE_CLIENT_DBG_FIFO_STATUS)); 477 #endif 478 } 479 480 static inline void rk_pcie_link_status_clear(struct rk_pcie *rk_pcie) 481 { 482 rk_pcie_writel_apb(rk_pcie, PCIE_CLIENT_GENERAL_DEBUG, 0x0); 483 } 484 485 static inline void rk_pcie_disable_ltssm(struct rk_pcie *rk_pcie) 486 { 487 rk_pcie_writel_apb(rk_pcie, 0x0, 0xc0008); 488 } 489 490 static inline void rk_pcie_enable_ltssm(struct rk_pcie *rk_pcie) 491 { 492 rk_pcie_writel_apb(rk_pcie, 0x0, 0xc000c); 493 } 494 495 static int is_link_up(struct rk_pcie *priv) 496 { 497 u32 val; 498 499 val = rk_pcie_readl_apb(priv, PCIE_CLIENT_LTSSM_STATUS); 500 if ((val & (RDLH_LINKUP | SMLH_LINKUP)) == 0x30000 && 501 (val & GENMASK(5, 0)) == 0x11) 502 return 1; 503 504 return 0; 505 } 506 507 static int rk_pcie_link_up(struct rk_pcie *priv, u32 cap_speed) 508 { 509 int retries; 510 511 if (is_link_up(priv)) { 512 printf("PCI Link already up before configuration!\n"); 513 return 1; 514 } 515 516 /* DW pre link configurations */ 517 rk_pcie_configure(priv, cap_speed); 518 519 /* Release the device */ 520 if (dm_gpio_is_valid(&priv->rst_gpio)) { 521 /* 522 * T_PVPERL (Power stable to PERST# inactive) should be a minimum of 100ms. 523 * We add a 200ms by default for sake of hoping everthings 524 * work fine. 525 */ 526 msleep(200); 527 dm_gpio_set_value(&priv->rst_gpio, 1); 528 /* 529 * Add this 20ms delay because we observe link is always up stably after it and 530 * could help us save 20ms for scanning devices. 531 */ 532 msleep(20); 533 } 534 535 rk_pcie_disable_ltssm(priv); 536 rk_pcie_link_status_clear(priv); 537 rk_pcie_enable_debug(priv); 538 539 /* Enable LTSSM */ 540 rk_pcie_enable_ltssm(priv); 541 542 for (retries = 0; retries < 50; retries++) { 543 if (is_link_up(priv)) { 544 dev_info(priv->dev, "PCIe Link up, LTSSM is 0x%x\n", 545 rk_pcie_readl_apb(priv, PCIE_CLIENT_LTSSM_STATUS)); 546 rk_pcie_debug_dump(priv); 547 /* Link maybe in Gen switch recovery but we need to wait more 1s */ 548 msleep(1000); 549 return 0; 550 } 551 552 dev_info(priv->dev, "PCIe Linking... LTSSM is 0x%x\n", 553 rk_pcie_readl_apb(priv, PCIE_CLIENT_LTSSM_STATUS)); 554 rk_pcie_debug_dump(priv); 555 msleep(10); 556 } 557 558 dev_err(priv->dev, "PCIe-%d Link Fail\n", priv->dev->seq); 559 return -EINVAL; 560 } 561 562 static int rockchip_pcie_init_port(struct udevice *dev) 563 { 564 int ret; 565 u32 val; 566 struct rk_pcie *priv = dev_get_priv(dev); 567 union phy_configure_opts phy_cfg; 568 569 /* Rest the device */ 570 if (dm_gpio_is_valid(&priv->rst_gpio)) 571 dm_gpio_set_value(&priv->rst_gpio, 0); 572 573 /* Set power and maybe external ref clk input */ 574 if (priv->vpcie3v3) { 575 ret = regulator_set_enable(priv->vpcie3v3, true); 576 if (ret) { 577 dev_err(priv->dev, "failed to enable vpcie3v3 (ret=%d)\n", 578 ret); 579 return ret; 580 } 581 } 582 583 if (priv->is_bifurcation) { 584 phy_cfg.pcie.is_bifurcation = true; 585 ret = generic_phy_configure(&priv->phy, &phy_cfg); 586 if (ret) 587 dev_err(dev, "failed to set bifurcation for phy (ret=%d)\n", ret); 588 } 589 590 ret = generic_phy_init(&priv->phy); 591 if (ret) { 592 dev_err(dev, "failed to init phy (ret=%d)\n", ret); 593 return ret; 594 } 595 596 ret = generic_phy_power_on(&priv->phy); 597 if (ret) { 598 dev_err(dev, "failed to power on phy (ret=%d)\n", ret); 599 goto err_exit_phy; 600 } 601 602 ret = reset_deassert_bulk(&priv->rsts); 603 if (ret) { 604 dev_err(dev, "failed to deassert resets (ret=%d)\n", ret); 605 goto err_power_off_phy; 606 } 607 608 ret = clk_enable_bulk(&priv->clks); 609 if (ret) { 610 dev_err(dev, "failed to enable clks (ret=%d)\n", ret); 611 goto err_deassert_bulk; 612 } 613 614 /* LTSSM EN ctrl mode */ 615 val = rk_pcie_readl_apb(priv, PCIE_CLIENT_HOT_RESET_CTRL); 616 val |= PCIE_LTSSM_ENABLE_ENHANCE | (PCIE_LTSSM_ENABLE_ENHANCE << 16); 617 rk_pcie_writel_apb(priv, PCIE_CLIENT_HOT_RESET_CTRL, val); 618 619 /* Set RC mode */ 620 rk_pcie_writel_apb(priv, 0x0, 0xf00040); 621 rk_pcie_setup_host(priv); 622 623 ret = rk_pcie_link_up(priv, priv->gen); 624 if (ret < 0) 625 goto err_link_up; 626 627 return 0; 628 err_link_up: 629 clk_disable_bulk(&priv->clks); 630 err_deassert_bulk: 631 reset_assert_bulk(&priv->rsts); 632 err_power_off_phy: 633 generic_phy_power_off(&priv->phy); 634 err_exit_phy: 635 generic_phy_exit(&priv->phy); 636 return ret; 637 } 638 639 static int rockchip_pcie_parse_dt(struct udevice *dev) 640 { 641 struct rk_pcie *priv = dev_get_priv(dev); 642 u32 max_link_speed; 643 int ret; 644 645 priv->dbi_base = (void *)dev_read_addr_index(dev, 0); 646 if (!priv->dbi_base) 647 return -ENODEV; 648 649 dev_dbg(dev, "DBI address is 0x%p\n", priv->dbi_base); 650 651 priv->apb_base = (void *)dev_read_addr_index(dev, 1); 652 if (!priv->apb_base) 653 return -ENODEV; 654 655 dev_dbg(dev, "APB address is 0x%p\n", priv->apb_base); 656 657 ret = gpio_request_by_name(dev, "reset-gpios", 0, 658 &priv->rst_gpio, GPIOD_IS_OUT); 659 if (ret) { 660 dev_err(dev, "failed to find reset-gpios property\n"); 661 return ret; 662 } 663 664 ret = reset_get_bulk(dev, &priv->rsts); 665 if (ret) { 666 dev_err(dev, "Can't get reset: %d\n", ret); 667 return ret; 668 } 669 670 ret = clk_get_bulk(dev, &priv->clks); 671 if (ret) { 672 dev_err(dev, "Can't get clock: %d\n", ret); 673 return ret; 674 } 675 676 ret = device_get_supply_regulator(dev, "vpcie3v3-supply", 677 &priv->vpcie3v3); 678 if (ret && ret != -ENOENT) { 679 dev_err(dev, "failed to get vpcie3v3 supply (ret=%d)\n", ret); 680 return ret; 681 } 682 683 ret = generic_phy_get_by_index(dev, 0, &priv->phy); 684 if (ret) { 685 dev_err(dev, "failed to get pcie phy (ret=%d)\n", ret); 686 return ret; 687 } 688 689 if (dev_read_bool(dev, "rockchip,bifurcation")) 690 priv->is_bifurcation = true; 691 692 ret = ofnode_read_u32(dev->node, "max-link-speed", &max_link_speed); 693 if (ret < 0 || max_link_speed > 4) 694 priv->gen = 0; 695 else 696 priv->gen = max_link_speed; 697 698 return 0; 699 } 700 701 static int rockchip_pcie_probe(struct udevice *dev) 702 { 703 struct rk_pcie *priv = dev_get_priv(dev); 704 struct udevice *ctlr = pci_get_controller(dev); 705 struct pci_controller *hose = dev_get_uclass_priv(ctlr); 706 int ret; 707 708 priv->first_busno = dev->seq; 709 priv->dev = dev; 710 711 ret = rockchip_pcie_parse_dt(dev); 712 if (ret) 713 return ret; 714 715 ret = rockchip_pcie_init_port(dev); 716 if (ret) 717 return ret; 718 719 dev_info(dev, "PCIE-%d: Link up (Gen%d-x%d, Bus%d)\n", 720 dev->seq, rk_pcie_get_link_speed(priv), 721 rk_pcie_get_link_width(priv), 722 hose->first_busno); 723 724 for (ret = 0; ret < hose->region_count; ret++) { 725 if (hose->regions[ret].flags == PCI_REGION_IO) { 726 priv->io.phys_start = hose->regions[ret].phys_start; /* IO base */ 727 priv->io.bus_start = hose->regions[ret].bus_start; /* IO_bus_addr */ 728 priv->io.size = hose->regions[ret].size; /* IO size */ 729 } else if (hose->regions[ret].flags == PCI_REGION_MEM) { 730 priv->mem.phys_start = hose->regions[ret].phys_start; /* MEM base */ 731 priv->mem.bus_start = hose->regions[ret].bus_start; /* MEM_bus_addr */ 732 priv->mem.size = hose->regions[ret].size; /* MEM size */ 733 } else if (hose->regions[ret].flags == PCI_REGION_SYS_MEMORY) { 734 priv->cfg_base = (void *)(priv->io.phys_start - priv->io.size); 735 priv->cfg_size = priv->io.size; 736 } else { 737 dev_err(dev, "invalid flags type!\n"); 738 } 739 } 740 741 dev_dbg(dev, "Config space: [0x%p - 0x%p, size 0x%llx]\n", 742 priv->cfg_base, priv->cfg_base + priv->cfg_size, 743 priv->cfg_size); 744 745 dev_dbg(dev, "IO space: [0x%llx - 0x%llx, size 0x%x]\n", 746 priv->io.phys_start, priv->io.phys_start + priv->io.size, 747 priv->io.size); 748 749 dev_dbg(dev, "IO bus: [0x%x - 0x%x, size 0x%x]\n", 750 priv->io.bus_start, priv->io.bus_start + priv->io.size, 751 priv->io.size); 752 753 dev_dbg(dev, "MEM space: [0x%llx - 0x%llx, size 0x%x]\n", 754 priv->mem.phys_start, priv->mem.phys_start + priv->mem.size, 755 priv->mem.size); 756 757 dev_dbg(dev, "MEM bus: [0x%x - 0x%x, size 0x%x]\n", 758 priv->mem.bus_start, priv->mem.bus_start + priv->mem.size, 759 priv->mem.size); 760 761 rk_pcie_prog_outbound_atu_unroll(priv, PCIE_ATU_REGION_INDEX0, 762 PCIE_ATU_TYPE_MEM, 763 priv->mem.phys_start, 764 priv->mem.bus_start, priv->mem.size); 765 return 0; 766 } 767 768 static const struct dm_pci_ops rockchip_pcie_ops = { 769 .read_config = rockchip_pcie_rd_conf, 770 .write_config = rockchip_pcie_wr_conf, 771 }; 772 773 static const struct udevice_id rockchip_pcie_ids[] = { 774 { .compatible = "rockchip,rk3568-pcie" }, 775 { .compatible = "rockchip,rk3588-pcie" }, 776 { } 777 }; 778 779 U_BOOT_DRIVER(rockchip_pcie) = { 780 .name = "pcie_dw_rockchip", 781 .id = UCLASS_PCI, 782 .of_match = rockchip_pcie_ids, 783 .ops = &rockchip_pcie_ops, 784 .probe = rockchip_pcie_probe, 785 .priv_auto_alloc_size = sizeof(struct rk_pcie), 786 }; 787