1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * PCIe controller driver for Renesas R-Car Gen4 Series SoCs 4 * Copyright (C) 2022-2023 Renesas Electronics Corporation 5 * 6 * The r8a779g0 (R-Car V4H) controller requires a specific firmware to be 7 * provided, to initialize the PHY. Otherwise, the PCIe controller will not 8 * work. 9 */ 10 11 #include <linux/delay.h> 12 #include <linux/firmware.h> 13 #include <linux/interrupt.h> 14 #include <linux/io.h> 15 #include <linux/iopoll.h> 16 #include <linux/module.h> 17 #include <linux/of.h> 18 #include <linux/pci.h> 19 #include <linux/platform_device.h> 20 #include <linux/pm_runtime.h> 21 #include <linux/reset.h> 22 23 #include "../../pci.h" 24 #include "pcie-designware.h" 25 26 /* Renesas-specific */ 27 /* PCIe Mode Setting Register 0 */ 28 #define PCIEMSR0 0x0000 29 #define APP_SRIS_MODE BIT(6) 30 #define DEVICE_TYPE_EP 0 31 #define DEVICE_TYPE_RC BIT(4) 32 #define BIFUR_MOD_SET_ON BIT(0) 33 34 /* PCIe Interrupt Status 0 */ 35 #define PCIEINTSTS0 0x0084 36 37 /* PCIe Interrupt Status 0 Enable */ 38 #define PCIEINTSTS0EN 0x0310 39 #define MSI_CTRL_INT BIT(26) 40 #define SMLH_LINK_UP BIT(7) 41 #define RDLH_LINK_UP BIT(6) 42 43 /* PCIe DMA Interrupt Status Enable */ 44 #define PCIEDMAINTSTSEN 0x0314 45 #define PCIEDMAINTSTSEN_INIT GENMASK(15, 0) 46 47 /* Port Logic Registers 89 */ 48 #define PRTLGC89 0x0b70 49 50 /* Port Logic Registers 90 */ 51 #define PRTLGC90 0x0b74 52 53 /* PCIe Reset Control Register 1 */ 54 #define PCIERSTCTRL1 0x0014 55 #define APP_HOLD_PHY_RST BIT(16) 56 #define APP_LTSSM_ENABLE BIT(0) 57 58 /* PCIe Power Management Control */ 59 #define PCIEPWRMNGCTRL 0x0070 60 #define APP_CLK_REQ_N BIT(11) 61 #define APP_CLK_PM_EN BIT(10) 62 63 #define RCAR_NUM_SPEED_CHANGE_RETRIES 10 64 #define RCAR_MAX_LINK_SPEED 4 65 66 #define RCAR_GEN4_PCIE_EP_FUNC_DBI_OFFSET 0x1000 67 #define RCAR_GEN4_PCIE_EP_FUNC_DBI2_OFFSET 0x800 68 69 #define RCAR_GEN4_PCIE_FIRMWARE_NAME "rcar_gen4_pcie.bin" 70 #define RCAR_GEN4_PCIE_FIRMWARE_BASE_ADDR 0xc000 71 MODULE_FIRMWARE(RCAR_GEN4_PCIE_FIRMWARE_NAME); 72 73 struct rcar_gen4_pcie; 74 struct rcar_gen4_pcie_drvdata { 75 void (*additional_common_init)(struct rcar_gen4_pcie *rcar); 76 int (*ltssm_control)(struct rcar_gen4_pcie *rcar, bool enable); 77 enum dw_pcie_device_mode mode; 78 }; 79 80 struct rcar_gen4_pcie { 81 struct dw_pcie dw; 82 void __iomem *base; 83 void __iomem *phy_base; 84 struct platform_device *pdev; 85 const struct rcar_gen4_pcie_drvdata *drvdata; 86 }; 87 #define to_rcar_gen4_pcie(_dw) container_of(_dw, struct rcar_gen4_pcie, dw) 88 89 /* Common */ 90 static bool rcar_gen4_pcie_link_up(struct dw_pcie *dw) 91 { 92 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw); 93 u32 val, mask; 94 95 val = readl(rcar->base + PCIEINTSTS0); 96 mask = RDLH_LINK_UP | SMLH_LINK_UP; 97 98 return (val & mask) == mask; 99 } 100 101 /* 102 * Manually initiate the speed change. Return 0 if change succeeded; otherwise 103 * -ETIMEDOUT. 104 */ 105 static int rcar_gen4_pcie_speed_change(struct dw_pcie *dw) 106 { 107 u32 val; 108 int i; 109 110 val = dw_pcie_readl_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL); 111 val &= ~PORT_LOGIC_SPEED_CHANGE; 112 dw_pcie_writel_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL, val); 113 114 val = dw_pcie_readl_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL); 115 val |= PORT_LOGIC_SPEED_CHANGE; 116 dw_pcie_writel_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL, val); 117 118 for (i = 0; i < RCAR_NUM_SPEED_CHANGE_RETRIES; i++) { 119 val = dw_pcie_readl_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL); 120 if (!(val & PORT_LOGIC_SPEED_CHANGE)) 121 return 0; 122 usleep_range(10000, 11000); 123 } 124 125 return -ETIMEDOUT; 126 } 127 128 /* 129 * Enable LTSSM of this controller and manually initiate the speed change. 130 * Always return 0. 131 */ 132 static int rcar_gen4_pcie_start_link(struct dw_pcie *dw) 133 { 134 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw); 135 int i, changes, ret; 136 137 if (rcar->drvdata->ltssm_control) { 138 ret = rcar->drvdata->ltssm_control(rcar, true); 139 if (ret) 140 return ret; 141 } 142 143 /* 144 * Require direct speed change with retrying here if the max_link_speed 145 * is PCIe Gen2 or higher. 146 */ 147 changes = min_not_zero(dw->max_link_speed, RCAR_MAX_LINK_SPEED) - 1; 148 149 /* 150 * Since dw_pcie_setup_rc() sets it once, PCIe Gen2 will be trained. 151 * So, this needs remaining times for up to PCIe Gen4 if RC mode. 152 */ 153 if (changes && rcar->drvdata->mode == DW_PCIE_RC_TYPE) 154 changes--; 155 156 for (i = 0; i < changes; i++) { 157 /* It may not be connected in EP mode yet. So, break the loop */ 158 if (rcar_gen4_pcie_speed_change(dw)) 159 break; 160 } 161 162 return 0; 163 } 164 165 static void rcar_gen4_pcie_stop_link(struct dw_pcie *dw) 166 { 167 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw); 168 169 if (rcar->drvdata->ltssm_control) 170 rcar->drvdata->ltssm_control(rcar, false); 171 } 172 173 static int rcar_gen4_pcie_common_init(struct rcar_gen4_pcie *rcar) 174 { 175 struct dw_pcie *dw = &rcar->dw; 176 u32 val; 177 int ret; 178 179 ret = clk_bulk_prepare_enable(DW_PCIE_NUM_CORE_CLKS, dw->core_clks); 180 if (ret) { 181 dev_err(dw->dev, "Enabling core clocks failed\n"); 182 return ret; 183 } 184 185 if (!reset_control_status(dw->core_rsts[DW_PCIE_PWR_RST].rstc)) 186 reset_control_assert(dw->core_rsts[DW_PCIE_PWR_RST].rstc); 187 188 val = readl(rcar->base + PCIEMSR0); 189 if (rcar->drvdata->mode == DW_PCIE_RC_TYPE) { 190 val |= DEVICE_TYPE_RC; 191 } else if (rcar->drvdata->mode == DW_PCIE_EP_TYPE) { 192 val |= DEVICE_TYPE_EP; 193 } else { 194 ret = -EINVAL; 195 goto err_unprepare; 196 } 197 198 if (dw->num_lanes < 4) 199 val |= BIFUR_MOD_SET_ON; 200 201 writel(val, rcar->base + PCIEMSR0); 202 203 ret = reset_control_deassert(dw->core_rsts[DW_PCIE_PWR_RST].rstc); 204 if (ret) 205 goto err_unprepare; 206 207 if (rcar->drvdata->additional_common_init) 208 rcar->drvdata->additional_common_init(rcar); 209 210 return 0; 211 212 err_unprepare: 213 clk_bulk_disable_unprepare(DW_PCIE_NUM_CORE_CLKS, dw->core_clks); 214 215 return ret; 216 } 217 218 static void rcar_gen4_pcie_common_deinit(struct rcar_gen4_pcie *rcar) 219 { 220 struct dw_pcie *dw = &rcar->dw; 221 222 reset_control_assert(dw->core_rsts[DW_PCIE_PWR_RST].rstc); 223 clk_bulk_disable_unprepare(DW_PCIE_NUM_CORE_CLKS, dw->core_clks); 224 } 225 226 static int rcar_gen4_pcie_prepare(struct rcar_gen4_pcie *rcar) 227 { 228 struct device *dev = rcar->dw.dev; 229 int err; 230 231 pm_runtime_enable(dev); 232 err = pm_runtime_resume_and_get(dev); 233 if (err < 0) { 234 dev_err(dev, "Runtime resume failed\n"); 235 pm_runtime_disable(dev); 236 } 237 238 return err; 239 } 240 241 static void rcar_gen4_pcie_unprepare(struct rcar_gen4_pcie *rcar) 242 { 243 struct device *dev = rcar->dw.dev; 244 245 pm_runtime_put(dev); 246 pm_runtime_disable(dev); 247 } 248 249 static int rcar_gen4_pcie_get_resources(struct rcar_gen4_pcie *rcar) 250 { 251 rcar->phy_base = devm_platform_ioremap_resource_byname(rcar->pdev, "phy"); 252 if (IS_ERR(rcar->phy_base)) 253 return PTR_ERR(rcar->phy_base); 254 255 /* Renesas-specific registers */ 256 rcar->base = devm_platform_ioremap_resource_byname(rcar->pdev, "app"); 257 258 return PTR_ERR_OR_ZERO(rcar->base); 259 } 260 261 static const struct dw_pcie_ops dw_pcie_ops = { 262 .start_link = rcar_gen4_pcie_start_link, 263 .stop_link = rcar_gen4_pcie_stop_link, 264 .link_up = rcar_gen4_pcie_link_up, 265 }; 266 267 static struct rcar_gen4_pcie *rcar_gen4_pcie_alloc(struct platform_device *pdev) 268 { 269 struct device *dev = &pdev->dev; 270 struct rcar_gen4_pcie *rcar; 271 272 rcar = devm_kzalloc(dev, sizeof(*rcar), GFP_KERNEL); 273 if (!rcar) 274 return ERR_PTR(-ENOMEM); 275 276 rcar->dw.ops = &dw_pcie_ops; 277 rcar->dw.dev = dev; 278 rcar->pdev = pdev; 279 rcar->dw.edma.mf = EDMA_MF_EDMA_UNROLL; 280 dw_pcie_cap_set(&rcar->dw, REQ_RES); 281 platform_set_drvdata(pdev, rcar); 282 283 return rcar; 284 } 285 286 /* Host mode */ 287 static int rcar_gen4_pcie_host_init(struct dw_pcie_rp *pp) 288 { 289 struct dw_pcie *dw = to_dw_pcie_from_pp(pp); 290 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw); 291 int ret; 292 u32 val; 293 294 gpiod_set_value_cansleep(dw->pe_rst, 1); 295 296 ret = rcar_gen4_pcie_common_init(rcar); 297 if (ret) 298 return ret; 299 300 /* 301 * According to the section 3.5.7.2 "RC Mode" in DWC PCIe Dual Mode 302 * Rev.5.20a and 3.5.6.1 "RC mode" in DWC PCIe RC databook v5.20a, we 303 * should disable two BARs to avoid unnecessary memory assignment 304 * during device enumeration. 305 */ 306 dw_pcie_writel_dbi2(dw, PCI_BASE_ADDRESS_0, 0x0); 307 dw_pcie_writel_dbi2(dw, PCI_BASE_ADDRESS_1, 0x0); 308 309 /* Enable MSI interrupt signal */ 310 val = readl(rcar->base + PCIEINTSTS0EN); 311 val |= MSI_CTRL_INT; 312 writel(val, rcar->base + PCIEINTSTS0EN); 313 314 msleep(PCIE_T_PVPERL_MS); /* pe_rst requires 100msec delay */ 315 316 gpiod_set_value_cansleep(dw->pe_rst, 0); 317 318 return 0; 319 } 320 321 static void rcar_gen4_pcie_host_deinit(struct dw_pcie_rp *pp) 322 { 323 struct dw_pcie *dw = to_dw_pcie_from_pp(pp); 324 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw); 325 326 gpiod_set_value_cansleep(dw->pe_rst, 1); 327 rcar_gen4_pcie_common_deinit(rcar); 328 } 329 330 static const struct dw_pcie_host_ops rcar_gen4_pcie_host_ops = { 331 .init = rcar_gen4_pcie_host_init, 332 .deinit = rcar_gen4_pcie_host_deinit, 333 }; 334 335 static int rcar_gen4_add_dw_pcie_rp(struct rcar_gen4_pcie *rcar) 336 { 337 struct dw_pcie_rp *pp = &rcar->dw.pp; 338 339 if (!IS_ENABLED(CONFIG_PCIE_RCAR_GEN4_HOST)) 340 return -ENODEV; 341 342 pp->num_vectors = MAX_MSI_IRQS; 343 pp->ops = &rcar_gen4_pcie_host_ops; 344 345 return dw_pcie_host_init(pp); 346 } 347 348 static void rcar_gen4_remove_dw_pcie_rp(struct rcar_gen4_pcie *rcar) 349 { 350 dw_pcie_host_deinit(&rcar->dw.pp); 351 } 352 353 /* Endpoint mode */ 354 static void rcar_gen4_pcie_ep_pre_init(struct dw_pcie_ep *ep) 355 { 356 struct dw_pcie *dw = to_dw_pcie_from_ep(ep); 357 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw); 358 int ret; 359 360 ret = rcar_gen4_pcie_common_init(rcar); 361 if (ret) 362 return; 363 364 writel(PCIEDMAINTSTSEN_INIT, rcar->base + PCIEDMAINTSTSEN); 365 } 366 367 static void rcar_gen4_pcie_ep_init(struct dw_pcie_ep *ep) 368 { 369 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 370 enum pci_barno bar; 371 372 for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) 373 dw_pcie_ep_reset_bar(pci, bar); 374 } 375 376 static void rcar_gen4_pcie_ep_deinit(struct rcar_gen4_pcie *rcar) 377 { 378 writel(0, rcar->base + PCIEDMAINTSTSEN); 379 rcar_gen4_pcie_common_deinit(rcar); 380 } 381 382 static int rcar_gen4_pcie_ep_raise_irq(struct dw_pcie_ep *ep, u8 func_no, 383 unsigned int type, u16 interrupt_num) 384 { 385 struct dw_pcie *dw = to_dw_pcie_from_ep(ep); 386 387 switch (type) { 388 case PCI_IRQ_INTX: 389 return dw_pcie_ep_raise_intx_irq(ep, func_no); 390 case PCI_IRQ_MSI: 391 return dw_pcie_ep_raise_msi_irq(ep, func_no, interrupt_num); 392 default: 393 dev_err(dw->dev, "Unknown IRQ type\n"); 394 return -EINVAL; 395 } 396 397 return 0; 398 } 399 400 static const struct pci_epc_features rcar_gen4_pcie_epc_features = { 401 .linkup_notifier = false, 402 .msi_capable = true, 403 .msix_capable = false, 404 .bar[BAR_1] = { .type = BAR_RESERVED, }, 405 .bar[BAR_3] = { .type = BAR_RESERVED, }, 406 .bar[BAR_4] = { .type = BAR_FIXED, .fixed_size = 256 }, 407 .bar[BAR_5] = { .type = BAR_RESERVED, }, 408 .align = SZ_1M, 409 }; 410 411 static const struct pci_epc_features* 412 rcar_gen4_pcie_ep_get_features(struct dw_pcie_ep *ep) 413 { 414 return &rcar_gen4_pcie_epc_features; 415 } 416 417 static unsigned int rcar_gen4_pcie_ep_get_dbi_offset(struct dw_pcie_ep *ep, 418 u8 func_no) 419 { 420 return func_no * RCAR_GEN4_PCIE_EP_FUNC_DBI_OFFSET; 421 } 422 423 static unsigned int rcar_gen4_pcie_ep_get_dbi2_offset(struct dw_pcie_ep *ep, 424 u8 func_no) 425 { 426 return func_no * RCAR_GEN4_PCIE_EP_FUNC_DBI2_OFFSET; 427 } 428 429 static const struct dw_pcie_ep_ops pcie_ep_ops = { 430 .pre_init = rcar_gen4_pcie_ep_pre_init, 431 .init = rcar_gen4_pcie_ep_init, 432 .raise_irq = rcar_gen4_pcie_ep_raise_irq, 433 .get_features = rcar_gen4_pcie_ep_get_features, 434 .get_dbi_offset = rcar_gen4_pcie_ep_get_dbi_offset, 435 .get_dbi2_offset = rcar_gen4_pcie_ep_get_dbi2_offset, 436 }; 437 438 static int rcar_gen4_add_dw_pcie_ep(struct rcar_gen4_pcie *rcar) 439 { 440 struct dw_pcie_ep *ep = &rcar->dw.ep; 441 struct device *dev = rcar->dw.dev; 442 int ret; 443 444 if (!IS_ENABLED(CONFIG_PCIE_RCAR_GEN4_EP)) 445 return -ENODEV; 446 447 ep->ops = &pcie_ep_ops; 448 449 ret = dw_pcie_ep_init(ep); 450 if (ret) { 451 rcar_gen4_pcie_ep_deinit(rcar); 452 return ret; 453 } 454 455 ret = dw_pcie_ep_init_registers(ep); 456 if (ret) { 457 dev_err(dev, "Failed to initialize DWC endpoint registers\n"); 458 dw_pcie_ep_deinit(ep); 459 rcar_gen4_pcie_ep_deinit(rcar); 460 } 461 462 pci_epc_init_notify(ep->epc); 463 464 return ret; 465 } 466 467 static void rcar_gen4_remove_dw_pcie_ep(struct rcar_gen4_pcie *rcar) 468 { 469 dw_pcie_ep_deinit(&rcar->dw.ep); 470 rcar_gen4_pcie_ep_deinit(rcar); 471 } 472 473 /* Common */ 474 static int rcar_gen4_add_dw_pcie(struct rcar_gen4_pcie *rcar) 475 { 476 rcar->drvdata = of_device_get_match_data(&rcar->pdev->dev); 477 if (!rcar->drvdata) 478 return -EINVAL; 479 480 switch (rcar->drvdata->mode) { 481 case DW_PCIE_RC_TYPE: 482 return rcar_gen4_add_dw_pcie_rp(rcar); 483 case DW_PCIE_EP_TYPE: 484 return rcar_gen4_add_dw_pcie_ep(rcar); 485 default: 486 return -EINVAL; 487 } 488 } 489 490 static int rcar_gen4_pcie_probe(struct platform_device *pdev) 491 { 492 struct rcar_gen4_pcie *rcar; 493 int err; 494 495 rcar = rcar_gen4_pcie_alloc(pdev); 496 if (IS_ERR(rcar)) 497 return PTR_ERR(rcar); 498 499 err = rcar_gen4_pcie_get_resources(rcar); 500 if (err) 501 return err; 502 503 err = rcar_gen4_pcie_prepare(rcar); 504 if (err) 505 return err; 506 507 err = rcar_gen4_add_dw_pcie(rcar); 508 if (err) 509 goto err_unprepare; 510 511 return 0; 512 513 err_unprepare: 514 rcar_gen4_pcie_unprepare(rcar); 515 516 return err; 517 } 518 519 static void rcar_gen4_remove_dw_pcie(struct rcar_gen4_pcie *rcar) 520 { 521 switch (rcar->drvdata->mode) { 522 case DW_PCIE_RC_TYPE: 523 rcar_gen4_remove_dw_pcie_rp(rcar); 524 break; 525 case DW_PCIE_EP_TYPE: 526 rcar_gen4_remove_dw_pcie_ep(rcar); 527 break; 528 default: 529 break; 530 } 531 } 532 533 static void rcar_gen4_pcie_remove(struct platform_device *pdev) 534 { 535 struct rcar_gen4_pcie *rcar = platform_get_drvdata(pdev); 536 537 rcar_gen4_remove_dw_pcie(rcar); 538 rcar_gen4_pcie_unprepare(rcar); 539 } 540 541 static int r8a779f0_pcie_ltssm_control(struct rcar_gen4_pcie *rcar, bool enable) 542 { 543 u32 val; 544 545 val = readl(rcar->base + PCIERSTCTRL1); 546 if (enable) { 547 val |= APP_LTSSM_ENABLE; 548 val &= ~APP_HOLD_PHY_RST; 549 } else { 550 /* 551 * Since the datasheet of R-Car doesn't mention how to assert 552 * the APP_HOLD_PHY_RST, don't assert it again. Otherwise, 553 * hang-up issue happened in the dw_edma_core_off() when 554 * the controller didn't detect a PCI device. 555 */ 556 val &= ~APP_LTSSM_ENABLE; 557 } 558 writel(val, rcar->base + PCIERSTCTRL1); 559 560 return 0; 561 } 562 563 static void rcar_gen4_pcie_additional_common_init(struct rcar_gen4_pcie *rcar) 564 { 565 struct dw_pcie *dw = &rcar->dw; 566 u32 val; 567 568 val = dw_pcie_readl_dbi(dw, PCIE_PORT_LANE_SKEW); 569 val &= ~PORT_LANE_SKEW_INSERT_MASK; 570 if (dw->num_lanes < 4) 571 val |= BIT(6); 572 dw_pcie_writel_dbi(dw, PCIE_PORT_LANE_SKEW, val); 573 574 val = readl(rcar->base + PCIEPWRMNGCTRL); 575 val |= APP_CLK_REQ_N | APP_CLK_PM_EN; 576 writel(val, rcar->base + PCIEPWRMNGCTRL); 577 } 578 579 static void rcar_gen4_pcie_phy_reg_update_bits(struct rcar_gen4_pcie *rcar, 580 u32 offset, u32 mask, u32 val) 581 { 582 u32 tmp; 583 584 tmp = readl(rcar->phy_base + offset); 585 tmp &= ~mask; 586 tmp |= val; 587 writel(tmp, rcar->phy_base + offset); 588 } 589 590 /* 591 * SoC datasheet suggests checking port logic register bits during firmware 592 * write. If read returns non-zero value, then this function returns -EAGAIN 593 * indicating that the write needs to be done again. If read returns zero, 594 * then return 0 to indicate success. 595 */ 596 static int rcar_gen4_pcie_reg_test_bit(struct rcar_gen4_pcie *rcar, 597 u32 offset, u32 mask) 598 { 599 struct dw_pcie *dw = &rcar->dw; 600 601 if (dw_pcie_readl_dbi(dw, offset) & mask) 602 return -EAGAIN; 603 604 return 0; 605 } 606 607 static int rcar_gen4_pcie_download_phy_firmware(struct rcar_gen4_pcie *rcar) 608 { 609 /* The check_addr values are magical numbers in the datasheet */ 610 static const u32 check_addr[] = { 611 0x00101018, 612 0x00101118, 613 0x00101021, 614 0x00101121, 615 }; 616 struct dw_pcie *dw = &rcar->dw; 617 const struct firmware *fw; 618 unsigned int i, timeout; 619 u32 data; 620 int ret; 621 622 ret = request_firmware(&fw, RCAR_GEN4_PCIE_FIRMWARE_NAME, dw->dev); 623 if (ret) { 624 dev_err(dw->dev, "Failed to load firmware (%s): %d\n", 625 RCAR_GEN4_PCIE_FIRMWARE_NAME, ret); 626 return ret; 627 } 628 629 for (i = 0; i < (fw->size / 2); i++) { 630 data = fw->data[(i * 2) + 1] << 8 | fw->data[i * 2]; 631 timeout = 100; 632 do { 633 dw_pcie_writel_dbi(dw, PRTLGC89, RCAR_GEN4_PCIE_FIRMWARE_BASE_ADDR + i); 634 dw_pcie_writel_dbi(dw, PRTLGC90, data); 635 if (!rcar_gen4_pcie_reg_test_bit(rcar, PRTLGC89, BIT(30))) 636 break; 637 if (!(--timeout)) { 638 ret = -ETIMEDOUT; 639 goto exit; 640 } 641 usleep_range(100, 200); 642 } while (1); 643 } 644 645 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x0f8, BIT(17), BIT(17)); 646 647 for (i = 0; i < ARRAY_SIZE(check_addr); i++) { 648 timeout = 100; 649 do { 650 dw_pcie_writel_dbi(dw, PRTLGC89, check_addr[i]); 651 ret = rcar_gen4_pcie_reg_test_bit(rcar, PRTLGC89, BIT(30)); 652 ret |= rcar_gen4_pcie_reg_test_bit(rcar, PRTLGC90, BIT(0)); 653 if (!ret) 654 break; 655 if (!(--timeout)) { 656 ret = -ETIMEDOUT; 657 goto exit; 658 } 659 usleep_range(100, 200); 660 } while (1); 661 } 662 663 exit: 664 release_firmware(fw); 665 666 return ret; 667 } 668 669 static int rcar_gen4_pcie_ltssm_control(struct rcar_gen4_pcie *rcar, bool enable) 670 { 671 struct dw_pcie *dw = &rcar->dw; 672 u32 val; 673 int ret; 674 675 if (!enable) { 676 val = readl(rcar->base + PCIERSTCTRL1); 677 val &= ~APP_LTSSM_ENABLE; 678 writel(val, rcar->base + PCIERSTCTRL1); 679 680 return 0; 681 } 682 683 val = dw_pcie_readl_dbi(dw, PCIE_PORT_FORCE); 684 val |= PORT_FORCE_DO_DESKEW_FOR_SRIS; 685 dw_pcie_writel_dbi(dw, PCIE_PORT_FORCE, val); 686 687 val = readl(rcar->base + PCIEMSR0); 688 val |= APP_SRIS_MODE; 689 writel(val, rcar->base + PCIEMSR0); 690 691 /* 692 * The R-Car Gen4 datasheet doesn't describe the PHY registers' name. 693 * But, the initialization procedure describes these offsets. So, 694 * this driver has magical offset numbers. 695 */ 696 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x700, BIT(28), 0); 697 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x700, BIT(20), 0); 698 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x700, BIT(12), 0); 699 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x700, BIT(4), 0); 700 701 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x148, GENMASK(23, 22), BIT(22)); 702 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x148, GENMASK(18, 16), GENMASK(17, 16)); 703 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x148, GENMASK(7, 6), BIT(6)); 704 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x148, GENMASK(2, 0), GENMASK(11, 0)); 705 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x1d4, GENMASK(16, 15), GENMASK(16, 15)); 706 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x514, BIT(26), BIT(26)); 707 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x0f8, BIT(16), 0); 708 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x0f8, BIT(19), BIT(19)); 709 710 val = readl(rcar->base + PCIERSTCTRL1); 711 val &= ~APP_HOLD_PHY_RST; 712 writel(val, rcar->base + PCIERSTCTRL1); 713 714 ret = readl_poll_timeout(rcar->phy_base + 0x0f8, val, !(val & BIT(18)), 100, 10000); 715 if (ret < 0) 716 return ret; 717 718 ret = rcar_gen4_pcie_download_phy_firmware(rcar); 719 if (ret) 720 return ret; 721 722 val = readl(rcar->base + PCIERSTCTRL1); 723 val |= APP_LTSSM_ENABLE; 724 writel(val, rcar->base + PCIERSTCTRL1); 725 726 return 0; 727 } 728 729 static struct rcar_gen4_pcie_drvdata drvdata_r8a779f0_pcie = { 730 .ltssm_control = r8a779f0_pcie_ltssm_control, 731 .mode = DW_PCIE_RC_TYPE, 732 }; 733 734 static struct rcar_gen4_pcie_drvdata drvdata_r8a779f0_pcie_ep = { 735 .ltssm_control = r8a779f0_pcie_ltssm_control, 736 .mode = DW_PCIE_EP_TYPE, 737 }; 738 739 static struct rcar_gen4_pcie_drvdata drvdata_rcar_gen4_pcie = { 740 .additional_common_init = rcar_gen4_pcie_additional_common_init, 741 .ltssm_control = rcar_gen4_pcie_ltssm_control, 742 .mode = DW_PCIE_RC_TYPE, 743 }; 744 745 static struct rcar_gen4_pcie_drvdata drvdata_rcar_gen4_pcie_ep = { 746 .additional_common_init = rcar_gen4_pcie_additional_common_init, 747 .ltssm_control = rcar_gen4_pcie_ltssm_control, 748 .mode = DW_PCIE_EP_TYPE, 749 }; 750 751 static const struct of_device_id rcar_gen4_pcie_of_match[] = { 752 { 753 .compatible = "renesas,r8a779f0-pcie", 754 .data = &drvdata_r8a779f0_pcie, 755 }, 756 { 757 .compatible = "renesas,r8a779f0-pcie-ep", 758 .data = &drvdata_r8a779f0_pcie_ep, 759 }, 760 { 761 .compatible = "renesas,rcar-gen4-pcie", 762 .data = &drvdata_rcar_gen4_pcie, 763 }, 764 { 765 .compatible = "renesas,rcar-gen4-pcie-ep", 766 .data = &drvdata_rcar_gen4_pcie_ep, 767 }, 768 {}, 769 }; 770 MODULE_DEVICE_TABLE(of, rcar_gen4_pcie_of_match); 771 772 static struct platform_driver rcar_gen4_pcie_driver = { 773 .driver = { 774 .name = "pcie-rcar-gen4", 775 .of_match_table = rcar_gen4_pcie_of_match, 776 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 777 }, 778 .probe = rcar_gen4_pcie_probe, 779 .remove = rcar_gen4_pcie_remove, 780 }; 781 module_platform_driver(rcar_gen4_pcie_driver); 782 783 MODULE_DESCRIPTION("Renesas R-Car Gen4 PCIe controller driver"); 784 MODULE_LICENSE("GPL"); 785