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 * R-Car V4H Reference Manual R19UH0186EJ0130 Rev.1.30 Apr. 189 * 21, 2025 page 585 Figure 9.3.2 Software Reset flow (B) 190 * indicates that for peripherals in HSC domain, after 191 * reset has been asserted by writing a matching reset bit 192 * into register SRCR, it is mandatory to wait 1ms. 193 */ 194 fsleep(1000); 195 } 196 197 val = readl(rcar->base + PCIEMSR0); 198 if (rcar->drvdata->mode == DW_PCIE_RC_TYPE) { 199 val |= DEVICE_TYPE_RC; 200 } else if (rcar->drvdata->mode == DW_PCIE_EP_TYPE) { 201 val |= DEVICE_TYPE_EP; 202 } else { 203 ret = -EINVAL; 204 goto err_unprepare; 205 } 206 207 if (dw->num_lanes < 4) 208 val |= BIFUR_MOD_SET_ON; 209 210 writel(val, rcar->base + PCIEMSR0); 211 212 ret = reset_control_deassert(dw->core_rsts[DW_PCIE_PWR_RST].rstc); 213 if (ret) 214 goto err_unprepare; 215 216 /* 217 * Assure the reset is latched and the core is ready for DBI access. 218 * On R-Car V4H, the PCIe reset is asynchronous and does not take 219 * effect immediately, but needs a short time to complete. In case 220 * DBI access happens in that short time, that access generates an 221 * SError. To make sure that condition can never happen, read back the 222 * state of the reset, which should turn the asynchronous reset into 223 * synchronous one, and wait a little over 1ms to add additional 224 * safety margin. 225 */ 226 reset_control_status(dw->core_rsts[DW_PCIE_PWR_RST].rstc); 227 fsleep(1000); 228 229 if (rcar->drvdata->additional_common_init) 230 rcar->drvdata->additional_common_init(rcar); 231 232 return 0; 233 234 err_unprepare: 235 clk_bulk_disable_unprepare(DW_PCIE_NUM_CORE_CLKS, dw->core_clks); 236 237 return ret; 238 } 239 240 static void rcar_gen4_pcie_common_deinit(struct rcar_gen4_pcie *rcar) 241 { 242 struct dw_pcie *dw = &rcar->dw; 243 244 reset_control_assert(dw->core_rsts[DW_PCIE_PWR_RST].rstc); 245 clk_bulk_disable_unprepare(DW_PCIE_NUM_CORE_CLKS, dw->core_clks); 246 } 247 248 static int rcar_gen4_pcie_prepare(struct rcar_gen4_pcie *rcar) 249 { 250 struct device *dev = rcar->dw.dev; 251 int err; 252 253 pm_runtime_enable(dev); 254 err = pm_runtime_resume_and_get(dev); 255 if (err < 0) { 256 dev_err(dev, "Runtime resume failed\n"); 257 pm_runtime_disable(dev); 258 } 259 260 return err; 261 } 262 263 static void rcar_gen4_pcie_unprepare(struct rcar_gen4_pcie *rcar) 264 { 265 struct device *dev = rcar->dw.dev; 266 267 pm_runtime_put(dev); 268 pm_runtime_disable(dev); 269 } 270 271 static int rcar_gen4_pcie_get_resources(struct rcar_gen4_pcie *rcar) 272 { 273 rcar->phy_base = devm_platform_ioremap_resource_byname(rcar->pdev, "phy"); 274 if (IS_ERR(rcar->phy_base)) 275 return PTR_ERR(rcar->phy_base); 276 277 /* Renesas-specific registers */ 278 rcar->base = devm_platform_ioremap_resource_byname(rcar->pdev, "app"); 279 280 return PTR_ERR_OR_ZERO(rcar->base); 281 } 282 283 static const struct dw_pcie_ops dw_pcie_ops = { 284 .start_link = rcar_gen4_pcie_start_link, 285 .stop_link = rcar_gen4_pcie_stop_link, 286 .link_up = rcar_gen4_pcie_link_up, 287 }; 288 289 static struct rcar_gen4_pcie *rcar_gen4_pcie_alloc(struct platform_device *pdev) 290 { 291 struct device *dev = &pdev->dev; 292 struct rcar_gen4_pcie *rcar; 293 294 rcar = devm_kzalloc(dev, sizeof(*rcar), GFP_KERNEL); 295 if (!rcar) 296 return ERR_PTR(-ENOMEM); 297 298 rcar->dw.ops = &dw_pcie_ops; 299 rcar->dw.dev = dev; 300 rcar->pdev = pdev; 301 rcar->dw.edma.mf = EDMA_MF_EDMA_UNROLL; 302 dw_pcie_cap_set(&rcar->dw, REQ_RES); 303 platform_set_drvdata(pdev, rcar); 304 305 return rcar; 306 } 307 308 /* Host mode */ 309 static int rcar_gen4_pcie_host_init(struct dw_pcie_rp *pp) 310 { 311 struct dw_pcie *dw = to_dw_pcie_from_pp(pp); 312 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw); 313 int ret; 314 u32 val; 315 316 gpiod_set_value_cansleep(dw->pe_rst, 1); 317 318 ret = rcar_gen4_pcie_common_init(rcar); 319 if (ret) 320 return ret; 321 322 /* 323 * According to the section 3.5.7.2 "RC Mode" in DWC PCIe Dual Mode 324 * Rev.5.20a and 3.5.6.1 "RC mode" in DWC PCIe RC databook v5.20a, we 325 * should disable two BARs to avoid unnecessary memory assignment 326 * during device enumeration. 327 */ 328 dw_pcie_writel_dbi2(dw, PCI_BASE_ADDRESS_0, 0x0); 329 dw_pcie_writel_dbi2(dw, PCI_BASE_ADDRESS_1, 0x0); 330 331 /* Enable MSI interrupt signal */ 332 val = readl(rcar->base + PCIEINTSTS0EN); 333 val |= MSI_CTRL_INT; 334 writel(val, rcar->base + PCIEINTSTS0EN); 335 336 msleep(PCIE_T_PVPERL_MS); /* pe_rst requires 100msec delay */ 337 338 gpiod_set_value_cansleep(dw->pe_rst, 0); 339 340 return 0; 341 } 342 343 static void rcar_gen4_pcie_host_deinit(struct dw_pcie_rp *pp) 344 { 345 struct dw_pcie *dw = to_dw_pcie_from_pp(pp); 346 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw); 347 348 gpiod_set_value_cansleep(dw->pe_rst, 1); 349 rcar_gen4_pcie_common_deinit(rcar); 350 } 351 352 static const struct dw_pcie_host_ops rcar_gen4_pcie_host_ops = { 353 .init = rcar_gen4_pcie_host_init, 354 .deinit = rcar_gen4_pcie_host_deinit, 355 }; 356 357 static int rcar_gen4_add_dw_pcie_rp(struct rcar_gen4_pcie *rcar) 358 { 359 struct dw_pcie_rp *pp = &rcar->dw.pp; 360 361 if (!IS_ENABLED(CONFIG_PCIE_RCAR_GEN4_HOST)) 362 return -ENODEV; 363 364 pp->num_vectors = MAX_MSI_IRQS; 365 pp->ops = &rcar_gen4_pcie_host_ops; 366 367 return dw_pcie_host_init(pp); 368 } 369 370 static void rcar_gen4_remove_dw_pcie_rp(struct rcar_gen4_pcie *rcar) 371 { 372 dw_pcie_host_deinit(&rcar->dw.pp); 373 } 374 375 /* Endpoint mode */ 376 static void rcar_gen4_pcie_ep_pre_init(struct dw_pcie_ep *ep) 377 { 378 struct dw_pcie *dw = to_dw_pcie_from_ep(ep); 379 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw); 380 int ret; 381 382 ret = rcar_gen4_pcie_common_init(rcar); 383 if (ret) 384 return; 385 386 writel(PCIEDMAINTSTSEN_INIT, rcar->base + PCIEDMAINTSTSEN); 387 } 388 389 static void rcar_gen4_pcie_ep_init(struct dw_pcie_ep *ep) 390 { 391 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 392 enum pci_barno bar; 393 394 for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) 395 dw_pcie_ep_reset_bar(pci, bar); 396 } 397 398 static void rcar_gen4_pcie_ep_deinit(struct rcar_gen4_pcie *rcar) 399 { 400 writel(0, rcar->base + PCIEDMAINTSTSEN); 401 rcar_gen4_pcie_common_deinit(rcar); 402 } 403 404 static int rcar_gen4_pcie_ep_raise_irq(struct dw_pcie_ep *ep, u8 func_no, 405 unsigned int type, u16 interrupt_num) 406 { 407 struct dw_pcie *dw = to_dw_pcie_from_ep(ep); 408 409 switch (type) { 410 case PCI_IRQ_INTX: 411 return dw_pcie_ep_raise_intx_irq(ep, func_no); 412 case PCI_IRQ_MSI: 413 return dw_pcie_ep_raise_msi_irq(ep, func_no, interrupt_num); 414 default: 415 dev_err(dw->dev, "Unknown IRQ type\n"); 416 return -EINVAL; 417 } 418 419 return 0; 420 } 421 422 static const struct pci_epc_features rcar_gen4_pcie_epc_features = { 423 .msi_capable = true, 424 .bar[BAR_1] = { .type = BAR_RESERVED, }, 425 .bar[BAR_3] = { .type = BAR_RESERVED, }, 426 .bar[BAR_4] = { .type = BAR_FIXED, .fixed_size = 256 }, 427 .bar[BAR_5] = { .type = BAR_RESERVED, }, 428 .align = SZ_1M, 429 }; 430 431 static const struct pci_epc_features* 432 rcar_gen4_pcie_ep_get_features(struct dw_pcie_ep *ep) 433 { 434 return &rcar_gen4_pcie_epc_features; 435 } 436 437 static unsigned int rcar_gen4_pcie_ep_get_dbi_offset(struct dw_pcie_ep *ep, 438 u8 func_no) 439 { 440 return func_no * RCAR_GEN4_PCIE_EP_FUNC_DBI_OFFSET; 441 } 442 443 static unsigned int rcar_gen4_pcie_ep_get_dbi2_offset(struct dw_pcie_ep *ep, 444 u8 func_no) 445 { 446 return func_no * RCAR_GEN4_PCIE_EP_FUNC_DBI2_OFFSET; 447 } 448 449 static const struct dw_pcie_ep_ops pcie_ep_ops = { 450 .pre_init = rcar_gen4_pcie_ep_pre_init, 451 .init = rcar_gen4_pcie_ep_init, 452 .raise_irq = rcar_gen4_pcie_ep_raise_irq, 453 .get_features = rcar_gen4_pcie_ep_get_features, 454 .get_dbi_offset = rcar_gen4_pcie_ep_get_dbi_offset, 455 .get_dbi2_offset = rcar_gen4_pcie_ep_get_dbi2_offset, 456 }; 457 458 static int rcar_gen4_add_dw_pcie_ep(struct rcar_gen4_pcie *rcar) 459 { 460 struct dw_pcie_ep *ep = &rcar->dw.ep; 461 struct device *dev = rcar->dw.dev; 462 int ret; 463 464 if (!IS_ENABLED(CONFIG_PCIE_RCAR_GEN4_EP)) 465 return -ENODEV; 466 467 ep->ops = &pcie_ep_ops; 468 469 ret = dw_pcie_ep_init(ep); 470 if (ret) { 471 rcar_gen4_pcie_ep_deinit(rcar); 472 return ret; 473 } 474 475 ret = dw_pcie_ep_init_registers(ep); 476 if (ret) { 477 dev_err(dev, "Failed to initialize DWC endpoint registers\n"); 478 dw_pcie_ep_deinit(ep); 479 rcar_gen4_pcie_ep_deinit(rcar); 480 } 481 482 pci_epc_init_notify(ep->epc); 483 484 return ret; 485 } 486 487 static void rcar_gen4_remove_dw_pcie_ep(struct rcar_gen4_pcie *rcar) 488 { 489 dw_pcie_ep_deinit(&rcar->dw.ep); 490 rcar_gen4_pcie_ep_deinit(rcar); 491 } 492 493 /* Common */ 494 static int rcar_gen4_add_dw_pcie(struct rcar_gen4_pcie *rcar) 495 { 496 rcar->drvdata = of_device_get_match_data(&rcar->pdev->dev); 497 if (!rcar->drvdata) 498 return -EINVAL; 499 500 switch (rcar->drvdata->mode) { 501 case DW_PCIE_RC_TYPE: 502 return rcar_gen4_add_dw_pcie_rp(rcar); 503 case DW_PCIE_EP_TYPE: 504 return rcar_gen4_add_dw_pcie_ep(rcar); 505 default: 506 return -EINVAL; 507 } 508 } 509 510 static int rcar_gen4_pcie_probe(struct platform_device *pdev) 511 { 512 struct rcar_gen4_pcie *rcar; 513 int err; 514 515 rcar = rcar_gen4_pcie_alloc(pdev); 516 if (IS_ERR(rcar)) 517 return PTR_ERR(rcar); 518 519 err = rcar_gen4_pcie_get_resources(rcar); 520 if (err) 521 return err; 522 523 err = rcar_gen4_pcie_prepare(rcar); 524 if (err) 525 return err; 526 527 err = rcar_gen4_add_dw_pcie(rcar); 528 if (err) 529 goto err_unprepare; 530 531 return 0; 532 533 err_unprepare: 534 rcar_gen4_pcie_unprepare(rcar); 535 536 return err; 537 } 538 539 static void rcar_gen4_remove_dw_pcie(struct rcar_gen4_pcie *rcar) 540 { 541 switch (rcar->drvdata->mode) { 542 case DW_PCIE_RC_TYPE: 543 rcar_gen4_remove_dw_pcie_rp(rcar); 544 break; 545 case DW_PCIE_EP_TYPE: 546 rcar_gen4_remove_dw_pcie_ep(rcar); 547 break; 548 default: 549 break; 550 } 551 } 552 553 static void rcar_gen4_pcie_remove(struct platform_device *pdev) 554 { 555 struct rcar_gen4_pcie *rcar = platform_get_drvdata(pdev); 556 557 rcar_gen4_remove_dw_pcie(rcar); 558 rcar_gen4_pcie_unprepare(rcar); 559 } 560 561 static int r8a779f0_pcie_ltssm_control(struct rcar_gen4_pcie *rcar, bool enable) 562 { 563 u32 val; 564 565 val = readl(rcar->base + PCIERSTCTRL1); 566 if (enable) { 567 val |= APP_LTSSM_ENABLE; 568 val &= ~APP_HOLD_PHY_RST; 569 } else { 570 /* 571 * Since the datasheet of R-Car doesn't mention how to assert 572 * the APP_HOLD_PHY_RST, don't assert it again. Otherwise, 573 * hang-up issue happened in the dw_edma_core_off() when 574 * the controller didn't detect a PCI device. 575 */ 576 val &= ~APP_LTSSM_ENABLE; 577 } 578 writel(val, rcar->base + PCIERSTCTRL1); 579 580 return 0; 581 } 582 583 static void rcar_gen4_pcie_additional_common_init(struct rcar_gen4_pcie *rcar) 584 { 585 struct dw_pcie *dw = &rcar->dw; 586 u32 val; 587 588 val = dw_pcie_readl_dbi(dw, PCIE_PORT_LANE_SKEW); 589 val &= ~PORT_LANE_SKEW_INSERT_MASK; 590 if (dw->num_lanes < 4) 591 val |= BIT(6); 592 dw_pcie_writel_dbi(dw, PCIE_PORT_LANE_SKEW, val); 593 594 val = readl(rcar->base + PCIEPWRMNGCTRL); 595 val |= APP_CLK_REQ_N | APP_CLK_PM_EN; 596 writel(val, rcar->base + PCIEPWRMNGCTRL); 597 } 598 599 static void rcar_gen4_pcie_phy_reg_update_bits(struct rcar_gen4_pcie *rcar, 600 u32 offset, u32 mask, u32 val) 601 { 602 u32 tmp; 603 604 tmp = readl(rcar->phy_base + offset); 605 tmp &= ~mask; 606 tmp |= val; 607 writel(tmp, rcar->phy_base + offset); 608 } 609 610 /* 611 * SoC datasheet suggests checking port logic register bits during firmware 612 * write. If read returns non-zero value, then this function returns -EAGAIN 613 * indicating that the write needs to be done again. If read returns zero, 614 * then return 0 to indicate success. 615 */ 616 static int rcar_gen4_pcie_reg_test_bit(struct rcar_gen4_pcie *rcar, 617 u32 offset, u32 mask) 618 { 619 struct dw_pcie *dw = &rcar->dw; 620 621 if (dw_pcie_readl_dbi(dw, offset) & mask) 622 return -EAGAIN; 623 624 return 0; 625 } 626 627 static int rcar_gen4_pcie_download_phy_firmware(struct rcar_gen4_pcie *rcar) 628 { 629 /* The check_addr values are magical numbers in the datasheet */ 630 static const u32 check_addr[] = { 631 0x00101018, 632 0x00101118, 633 0x00101021, 634 0x00101121, 635 }; 636 struct dw_pcie *dw = &rcar->dw; 637 const struct firmware *fw; 638 unsigned int i, timeout; 639 u32 data; 640 int ret; 641 642 ret = request_firmware(&fw, RCAR_GEN4_PCIE_FIRMWARE_NAME, dw->dev); 643 if (ret) { 644 dev_err(dw->dev, "Failed to load firmware (%s): %d\n", 645 RCAR_GEN4_PCIE_FIRMWARE_NAME, ret); 646 return ret; 647 } 648 649 for (i = 0; i < (fw->size / 2); i++) { 650 data = fw->data[(i * 2) + 1] << 8 | fw->data[i * 2]; 651 timeout = 100; 652 do { 653 dw_pcie_writel_dbi(dw, PRTLGC89, RCAR_GEN4_PCIE_FIRMWARE_BASE_ADDR + i); 654 dw_pcie_writel_dbi(dw, PRTLGC90, data); 655 if (!rcar_gen4_pcie_reg_test_bit(rcar, PRTLGC89, BIT(30))) 656 break; 657 if (!(--timeout)) { 658 ret = -ETIMEDOUT; 659 goto exit; 660 } 661 usleep_range(100, 200); 662 } while (1); 663 } 664 665 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x0f8, BIT(17), BIT(17)); 666 667 for (i = 0; i < ARRAY_SIZE(check_addr); i++) { 668 timeout = 100; 669 do { 670 dw_pcie_writel_dbi(dw, PRTLGC89, check_addr[i]); 671 ret = rcar_gen4_pcie_reg_test_bit(rcar, PRTLGC89, BIT(30)); 672 ret |= rcar_gen4_pcie_reg_test_bit(rcar, PRTLGC90, BIT(0)); 673 if (!ret) 674 break; 675 if (!(--timeout)) { 676 ret = -ETIMEDOUT; 677 goto exit; 678 } 679 usleep_range(100, 200); 680 } while (1); 681 } 682 683 exit: 684 release_firmware(fw); 685 686 return ret; 687 } 688 689 static int rcar_gen4_pcie_ltssm_control(struct rcar_gen4_pcie *rcar, bool enable) 690 { 691 struct dw_pcie *dw = &rcar->dw; 692 u32 val; 693 int ret; 694 695 if (!enable) { 696 val = readl(rcar->base + PCIERSTCTRL1); 697 val &= ~APP_LTSSM_ENABLE; 698 writel(val, rcar->base + PCIERSTCTRL1); 699 700 return 0; 701 } 702 703 val = dw_pcie_readl_dbi(dw, PCIE_PORT_FORCE); 704 val |= PORT_FORCE_DO_DESKEW_FOR_SRIS; 705 dw_pcie_writel_dbi(dw, PCIE_PORT_FORCE, val); 706 707 val = readl(rcar->base + PCIEMSR0); 708 val |= APP_SRIS_MODE; 709 writel(val, rcar->base + PCIEMSR0); 710 711 /* 712 * The R-Car Gen4 datasheet doesn't describe the PHY registers' name. 713 * But, the initialization procedure describes these offsets. So, 714 * this driver has magical offset numbers. 715 */ 716 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x700, BIT(28), 0); 717 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x700, BIT(20), 0); 718 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x700, BIT(12), 0); 719 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x700, BIT(4), 0); 720 721 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x148, GENMASK(23, 22), BIT(22)); 722 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x148, GENMASK(18, 16), GENMASK(17, 16)); 723 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x148, GENMASK(7, 6), BIT(6)); 724 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x148, GENMASK(2, 0), GENMASK(1, 0)); 725 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x1d4, GENMASK(16, 15), GENMASK(16, 15)); 726 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x514, BIT(26), BIT(26)); 727 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x0f8, BIT(16), 0); 728 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x0f8, BIT(19), BIT(19)); 729 730 val = readl(rcar->base + PCIERSTCTRL1); 731 val &= ~APP_HOLD_PHY_RST; 732 writel(val, rcar->base + PCIERSTCTRL1); 733 734 ret = readl_poll_timeout(rcar->phy_base + 0x0f8, val, val & BIT(18), 100, 10000); 735 if (ret < 0) 736 return ret; 737 738 ret = rcar_gen4_pcie_download_phy_firmware(rcar); 739 if (ret) 740 return ret; 741 742 val = readl(rcar->base + PCIERSTCTRL1); 743 val |= APP_LTSSM_ENABLE; 744 writel(val, rcar->base + PCIERSTCTRL1); 745 746 return 0; 747 } 748 749 static struct rcar_gen4_pcie_drvdata drvdata_r8a779f0_pcie = { 750 .ltssm_control = r8a779f0_pcie_ltssm_control, 751 .mode = DW_PCIE_RC_TYPE, 752 }; 753 754 static struct rcar_gen4_pcie_drvdata drvdata_r8a779f0_pcie_ep = { 755 .ltssm_control = r8a779f0_pcie_ltssm_control, 756 .mode = DW_PCIE_EP_TYPE, 757 }; 758 759 static struct rcar_gen4_pcie_drvdata drvdata_rcar_gen4_pcie = { 760 .additional_common_init = rcar_gen4_pcie_additional_common_init, 761 .ltssm_control = rcar_gen4_pcie_ltssm_control, 762 .mode = DW_PCIE_RC_TYPE, 763 }; 764 765 static struct rcar_gen4_pcie_drvdata drvdata_rcar_gen4_pcie_ep = { 766 .additional_common_init = rcar_gen4_pcie_additional_common_init, 767 .ltssm_control = rcar_gen4_pcie_ltssm_control, 768 .mode = DW_PCIE_EP_TYPE, 769 }; 770 771 static const struct of_device_id rcar_gen4_pcie_of_match[] = { 772 { 773 .compatible = "renesas,r8a779f0-pcie", 774 .data = &drvdata_r8a779f0_pcie, 775 }, 776 { 777 .compatible = "renesas,r8a779f0-pcie-ep", 778 .data = &drvdata_r8a779f0_pcie_ep, 779 }, 780 { 781 .compatible = "renesas,rcar-gen4-pcie", 782 .data = &drvdata_rcar_gen4_pcie, 783 }, 784 { 785 .compatible = "renesas,rcar-gen4-pcie-ep", 786 .data = &drvdata_rcar_gen4_pcie_ep, 787 }, 788 {}, 789 }; 790 MODULE_DEVICE_TABLE(of, rcar_gen4_pcie_of_match); 791 792 static struct platform_driver rcar_gen4_pcie_driver = { 793 .driver = { 794 .name = "pcie-rcar-gen4", 795 .of_match_table = rcar_gen4_pcie_of_match, 796 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 797 }, 798 .probe = rcar_gen4_pcie_probe, 799 .remove = rcar_gen4_pcie_remove, 800 }; 801 module_platform_driver(rcar_gen4_pcie_driver); 802 803 MODULE_DESCRIPTION("Renesas R-Car Gen4 PCIe controller driver"); 804 MODULE_LICENSE("GPL"); 805