drivers/pci/controller/dwc/pcie-rcar-gen4.c

   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
   7 #include <linux/delay.h>
   8 #include <linux/interrupt.h>
   9 #include <linux/io.h>
  10 #include <linux/module.h>
  11 #include <linux/of_device.h>
  12 #include <linux/pci.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/pm_runtime.h>
  15 #include <linux/reset.h>
  16
  17 #include "../../pci.h"
  18 #include "pcie-designware.h"
  19
  20 /* Renesas-specific */
  21 /* PCIe Mode Setting Register 0 */
  22 #define PCIEMSR0                0x0000
  23 #define BIFUR_MOD_SET_ON        BIT(0)
  24 #define DEVICE_TYPE_EP          0
  25 #define DEVICE_TYPE_RC          BIT(4)
  26
  27 /* PCIe Interrupt Status 0 */
  28 #define PCIEINTSTS0             0x0084
  29
  30 /* PCIe Interrupt Status 0 Enable */
  31 #define PCIEINTSTS0EN           0x0310
  32 #define MSI_CTRL_INT            BIT(26)
  33 #define SMLH_LINK_UP            BIT(7)
  34 #define RDLH_LINK_UP            BIT(6)
  35
  36 /* PCIe DMA Interrupt Status Enable */
  37 #define PCIEDMAINTSTSEN         0x0314
  38 #define PCIEDMAINTSTSEN_INIT    GENMASK(15, 0)
  39
  40 /* PCIe Reset Control Register 1 */
  41 #define PCIERSTCTRL1            0x0014
  42 #define APP_HOLD_PHY_RST        BIT(16)
  43 #define APP_LTSSM_ENABLE        BIT(0)
  44
  45 #define RCAR_NUM_SPEED_CHANGE_RETRIES   10
  46 #define RCAR_MAX_LINK_SPEED             4
  47
  48 #define RCAR_GEN4_PCIE_EP_FUNC_DBI_OFFSET       0x1000
  49 #define RCAR_GEN4_PCIE_EP_FUNC_DBI2_OFFSET      0x800
  50
  51 struct rcar_gen4_pcie {
  52         struct dw_pcie dw;
  53         void __iomem *base;
  54         struct platform_device *pdev;
  55         enum dw_pcie_device_mode mode;
  56 };
  57 #define to_rcar_gen4_pcie(_dw)  container_of(_dw, struct rcar_gen4_pcie, dw)
  58
  59 /* Common */
  60 static void rcar_gen4_pcie_ltssm_enable(struct rcar_gen4_pcie *rcar,
  61                                         bool enable)
  62 {
  63         u32 val;
  64
  65         val = readl(rcar->base + PCIERSTCTRL1);
  66         if (enable) {
  67                 val |= APP_LTSSM_ENABLE;
  68                 val &= ~APP_HOLD_PHY_RST;
  69         } else {
  70                 /*
  71                  * Since the datasheet of R-Car doesn't mention how to assert
  72                  * the APP_HOLD_PHY_RST, don't assert it again. Otherwise,
  73                  * hang-up issue happened in the dw_edma_core_off() when
  74                  * the controller didn't detect a PCI device.
  75                  */
  76                 val &= ~APP_LTSSM_ENABLE;
  77         }
  78         writel(val, rcar->base + PCIERSTCTRL1);
  79 }
  80
  81 static int rcar_gen4_pcie_link_up(struct dw_pcie *dw)
  82 {
  83         struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw);
  84         u32 val, mask;
  85
  86         val = readl(rcar->base + PCIEINTSTS0);
  87         mask = RDLH_LINK_UP | SMLH_LINK_UP;
  88
  89         return (val & mask) == mask;
  90 }
  91
  92 /*
  93  * Manually initiate the speed change. Return 0 if change succeeded; otherwise
  94  * -ETIMEDOUT.
  95  */
  96 static int rcar_gen4_pcie_speed_change(struct dw_pcie *dw)
  97 {
  98         u32 val;
  99         int i;
 100
 101         val = dw_pcie_readl_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL);
 102         val &= ~PORT_LOGIC_SPEED_CHANGE;
 103         dw_pcie_writel_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL, val);
 104
 105         val = dw_pcie_readl_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL);
 106         val |= PORT_LOGIC_SPEED_CHANGE;
 107         dw_pcie_writel_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL, val);
 108
 109         for (i = 0; i < RCAR_NUM_SPEED_CHANGE_RETRIES; i++) {
 110                 val = dw_pcie_readl_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL);
 111                 if (!(val & PORT_LOGIC_SPEED_CHANGE))
 112                         return 0;
 113                 usleep_range(10000, 11000);
 114         }
 115
 116         return -ETIMEDOUT;
 117 }
 118
 119 /*
 120  * Enable LTSSM of this controller and manually initiate the speed change.
 121  * Always return 0.
 122  */
 123 static int rcar_gen4_pcie_start_link(struct dw_pcie *dw)
 124 {
 125         struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw);
 126         int i, changes;
 127
 128         rcar_gen4_pcie_ltssm_enable(rcar, true);
 129
 130         /*
 131          * Require direct speed change with retrying here if the link_gen is
 132          * PCIe Gen2 or higher.
 133          */
 134         changes = min_not_zero(dw->link_gen, RCAR_MAX_LINK_SPEED) - 1;
 135
 136         /*
 137          * Since dw_pcie_setup_rc() sets it once, PCIe Gen2 will be trained.
 138          * So, this needs remaining times for up to PCIe Gen4 if RC mode.
 139          */
 140         if (changes && rcar->mode == DW_PCIE_RC_TYPE)
 141                 changes--;
 142
 143         for (i = 0; i < changes; i++) {
 144                 /* It may not be connected in EP mode yet. So, break the loop */
 145                 if (rcar_gen4_pcie_speed_change(dw))
 146                         break;
 147         }
 148
 149         return 0;
 150 }
 151
 152 static void rcar_gen4_pcie_stop_link(struct dw_pcie *dw)
 153 {
 154         struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw);
 155
 156         rcar_gen4_pcie_ltssm_enable(rcar, false);
 157 }
 158
 159 static int rcar_gen4_pcie_common_init(struct rcar_gen4_pcie *rcar)
 160 {
 161         struct dw_pcie *dw = &rcar->dw;
 162         u32 val;
 163         int ret;
 164
 165         ret = clk_bulk_prepare_enable(DW_PCIE_NUM_CORE_CLKS, dw->core_clks);
 166         if (ret) {
 167                 dev_err(dw->dev, "Enabling core clocks failed\n");
 168                 return ret;
 169         }
 170
 171         if (!reset_control_status(dw->core_rsts[DW_PCIE_PWR_RST].rstc))
 172                 reset_control_assert(dw->core_rsts[DW_PCIE_PWR_RST].rstc);
 173
 174         val = readl(rcar->base + PCIEMSR0);
 175         if (rcar->mode == DW_PCIE_RC_TYPE) {
 176                 val |= DEVICE_TYPE_RC;
 177         } else if (rcar->mode == DW_PCIE_EP_TYPE) {
 178                 val |= DEVICE_TYPE_EP;
 179         } else {
 180                 ret = -EINVAL;
 181                 goto err_unprepare;
 182         }
 183
 184         if (dw->num_lanes < 4)
 185                 val |= BIFUR_MOD_SET_ON;
 186
 187         writel(val, rcar->base + PCIEMSR0);
 188
 189         ret = reset_control_deassert(dw->core_rsts[DW_PCIE_PWR_RST].rstc);
 190         if (ret)
 191                 goto err_unprepare;
 192
 193         return 0;
 194
 195 err_unprepare:
 196         clk_bulk_disable_unprepare(DW_PCIE_NUM_CORE_CLKS, dw->core_clks);
 197
 198         return ret;
 199 }
 200
 201 static void rcar_gen4_pcie_common_deinit(struct rcar_gen4_pcie *rcar)
 202 {
 203         struct dw_pcie *dw = &rcar->dw;
 204
 205         reset_control_assert(dw->core_rsts[DW_PCIE_PWR_RST].rstc);
 206         clk_bulk_disable_unprepare(DW_PCIE_NUM_CORE_CLKS, dw->core_clks);
 207 }
 208
 209 static int rcar_gen4_pcie_prepare(struct rcar_gen4_pcie *rcar)
 210 {
 211         struct device *dev = rcar->dw.dev;
 212         int err;
 213
 214         pm_runtime_enable(dev);
 215         err = pm_runtime_resume_and_get(dev);
 216         if (err < 0) {
 217                 dev_err(dev, "Runtime resume failed\n");
 218                 pm_runtime_disable(dev);
 219         }
 220
 221         return err;
 222 }
 223
 224 static void rcar_gen4_pcie_unprepare(struct rcar_gen4_pcie *rcar)
 225 {
 226         struct device *dev = rcar->dw.dev;
 227
 228         pm_runtime_put(dev);
 229         pm_runtime_disable(dev);
 230 }
 231
 232 static int rcar_gen4_pcie_get_resources(struct rcar_gen4_pcie *rcar)
 233 {
 234         /* Renesas-specific registers */
 235         rcar->base = devm_platform_ioremap_resource_byname(rcar->pdev, "app");
 236
 237         return PTR_ERR_OR_ZERO(rcar->base);
 238 }
 239
 240 static const struct dw_pcie_ops dw_pcie_ops = {
 241         .start_link = rcar_gen4_pcie_start_link,
 242         .stop_link = rcar_gen4_pcie_stop_link,
 243         .link_up = rcar_gen4_pcie_link_up,
 244 };
 245
 246 static struct rcar_gen4_pcie *rcar_gen4_pcie_alloc(struct platform_device *pdev)
 247 {
 248         struct device *dev = &pdev->dev;
 249         struct rcar_gen4_pcie *rcar;
 250
 251         rcar = devm_kzalloc(dev, sizeof(*rcar), GFP_KERNEL);
 252         if (!rcar)
 253                 return ERR_PTR(-ENOMEM);
 254
 255         rcar->dw.ops = &dw_pcie_ops;
 256         rcar->dw.dev = dev;
 257         rcar->pdev = pdev;
 258         dw_pcie_cap_set(&rcar->dw, EDMA_UNROLL);
 259         dw_pcie_cap_set(&rcar->dw, REQ_RES);
 260         platform_set_drvdata(pdev, rcar);
 261
 262         return rcar;
 263 }
 264
 265 /* Host mode */
 266 static int rcar_gen4_pcie_host_init(struct dw_pcie_rp *pp)
 267 {
 268         struct dw_pcie *dw = to_dw_pcie_from_pp(pp);
 269         struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw);
 270         int ret;
 271         u32 val;
 272
 273         gpiod_set_value_cansleep(dw->pe_rst, 1);
 274
 275         ret = rcar_gen4_pcie_common_init(rcar);
 276         if (ret)
 277                 return ret;
 278
 279         /*
 280          * According to the section 3.5.7.2 "RC Mode" in DWC PCIe Dual Mode
 281          * Rev.5.20a and 3.5.6.1 "RC mode" in DWC PCIe RC databook v5.20a, we
 282          * should disable two BARs to avoid unnecessary memory assignment
 283          * during device enumeration.
 284          */
 285         dw_pcie_writel_dbi2(dw, PCI_BASE_ADDRESS_0, 0x0);
 286         dw_pcie_writel_dbi2(dw, PCI_BASE_ADDRESS_1, 0x0);
 287
 288         /* Enable MSI interrupt signal */
 289         val = readl(rcar->base + PCIEINTSTS0EN);
 290         val |= MSI_CTRL_INT;
 291         writel(val, rcar->base + PCIEINTSTS0EN);
 292
 293         msleep(PCIE_T_PVPERL_MS);       /* pe_rst requires 100msec delay */
 294
 295         gpiod_set_value_cansleep(dw->pe_rst, 0);
 296
 297         return 0;
 298 }
 299
 300 static void rcar_gen4_pcie_host_deinit(struct dw_pcie_rp *pp)
 301 {
 302         struct dw_pcie *dw = to_dw_pcie_from_pp(pp);
 303         struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw);
 304
 305         gpiod_set_value_cansleep(dw->pe_rst, 1);
 306         rcar_gen4_pcie_common_deinit(rcar);
 307 }
 308
 309 static const struct dw_pcie_host_ops rcar_gen4_pcie_host_ops = {
 310         .host_init = rcar_gen4_pcie_host_init,
 311         .host_deinit = rcar_gen4_pcie_host_deinit,
 312 };
 313
 314 static int rcar_gen4_add_dw_pcie_rp(struct rcar_gen4_pcie *rcar)
 315 {
 316         struct dw_pcie_rp *pp = &rcar->dw.pp;
 317
 318         if (!IS_ENABLED(CONFIG_PCIE_RCAR_GEN4_HOST))
 319                 return -ENODEV;
 320
 321         pp->num_vectors = MAX_MSI_IRQS;
 322         pp->ops = &rcar_gen4_pcie_host_ops;
 323
 324         return dw_pcie_host_init(pp);
 325 }
 326
 327 static void rcar_gen4_remove_dw_pcie_rp(struct rcar_gen4_pcie *rcar)
 328 {
 329         dw_pcie_host_deinit(&rcar->dw.pp);
 330 }
 331
 332 /* Endpoint mode */
 333 static void rcar_gen4_pcie_ep_pre_init(struct dw_pcie_ep *ep)
 334 {
 335         struct dw_pcie *dw = to_dw_pcie_from_ep(ep);
 336         struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw);
 337         int ret;
 338
 339         ret = rcar_gen4_pcie_common_init(rcar);
 340         if (ret)
 341                 return;
 342
 343         writel(PCIEDMAINTSTSEN_INIT, rcar->base + PCIEDMAINTSTSEN);
 344 }
 345
 346 static void rcar_gen4_pcie_ep_init(struct dw_pcie_ep *ep)
 347 {
 348         struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
 349         enum pci_barno bar;
 350
 351         for (bar = 0; bar < PCI_STD_NUM_BARS; bar++)
 352                 dw_pcie_ep_reset_bar(pci, bar);
 353 }
 354
 355 static void rcar_gen4_pcie_ep_deinit(struct dw_pcie_ep *ep)
 356 {
 357         struct dw_pcie *dw = to_dw_pcie_from_ep(ep);
 358         struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw);
 359
 360         writel(0, rcar->base + PCIEDMAINTSTSEN);
 361         rcar_gen4_pcie_common_deinit(rcar);
 362 }
 363
 364 static int rcar_gen4_pcie_ep_raise_irq(struct dw_pcie_ep *ep, u8 func_no,
 365                                        enum pci_epc_irq_type type,
 366                                        u16 interrupt_num)
 367 {
 368         struct dw_pcie *dw = to_dw_pcie_from_ep(ep);
 369
 370         switch (type) {
 371         case PCI_EPC_IRQ_LEGACY:
 372                 return dw_pcie_ep_raise_legacy_irq(ep, func_no);
 373         case PCI_EPC_IRQ_MSI:
 374                 return dw_pcie_ep_raise_msi_irq(ep, func_no, interrupt_num);
 375         default:
 376                 dev_err(dw->dev, "Unknown IRQ type\n");
 377                 return -EINVAL;
 378         }
 379
 380         return 0;
 381 }
 382
 383 static const struct pci_epc_features rcar_gen4_pcie_epc_features = {
 384         .linkup_notifier = false,
 385         .msi_capable = true,
 386         .msix_capable = false,
 387         .reserved_bar = 1 << BAR_1 | 1 << BAR_3 | 1 << BAR_5,
 388         .align = SZ_1M,
 389 };
 390
 391 static const struct pci_epc_features*
 392 rcar_gen4_pcie_ep_get_features(struct dw_pcie_ep *ep)
 393 {
 394         return &rcar_gen4_pcie_epc_features;
 395 }
 396
 397 static unsigned int rcar_gen4_pcie_ep_func_conf_select(struct dw_pcie_ep *ep,
 398                                                        u8 func_no)
 399 {
 400         return func_no * RCAR_GEN4_PCIE_EP_FUNC_DBI_OFFSET;
 401 }
 402
 403 static unsigned int rcar_gen4_pcie_ep_get_dbi2_offset(struct dw_pcie_ep *ep,
 404                                                       u8 func_no)
 405 {
 406         return func_no * RCAR_GEN4_PCIE_EP_FUNC_DBI2_OFFSET;
 407 }
 408
 409 static const struct dw_pcie_ep_ops pcie_ep_ops = {
 410         .pre_init = rcar_gen4_pcie_ep_pre_init,
 411         .ep_init = rcar_gen4_pcie_ep_init,
 412         .deinit = rcar_gen4_pcie_ep_deinit,
 413         .raise_irq = rcar_gen4_pcie_ep_raise_irq,
 414         .get_features = rcar_gen4_pcie_ep_get_features,
 415         .func_conf_select = rcar_gen4_pcie_ep_func_conf_select,
 416         .get_dbi2_offset = rcar_gen4_pcie_ep_get_dbi2_offset,
 417 };
 418
 419 static int rcar_gen4_add_dw_pcie_ep(struct rcar_gen4_pcie *rcar)
 420 {
 421         struct dw_pcie_ep *ep = &rcar->dw.ep;
 422
 423         if (!IS_ENABLED(CONFIG_PCIE_RCAR_GEN4_EP))
 424                 return -ENODEV;
 425
 426         ep->ops = &pcie_ep_ops;
 427
 428         return dw_pcie_ep_init(ep);
 429 }
 430
 431 static void rcar_gen4_remove_dw_pcie_ep(struct rcar_gen4_pcie *rcar)
 432 {
 433         dw_pcie_ep_exit(&rcar->dw.ep);
 434 }
 435
 436 /* Common */
 437 static int rcar_gen4_add_dw_pcie(struct rcar_gen4_pcie *rcar)
 438 {
 439         rcar->mode = (enum dw_pcie_device_mode)of_device_get_match_data(&rcar->pdev->dev);
 440
 441         switch (rcar->mode) {
 442         case DW_PCIE_RC_TYPE:
 443                 return rcar_gen4_add_dw_pcie_rp(rcar);
 444         case DW_PCIE_EP_TYPE:
 445                 return rcar_gen4_add_dw_pcie_ep(rcar);
 446         default:
 447                 return -EINVAL;
 448         }
 449 }
 450
 451 static int rcar_gen4_pcie_probe(struct platform_device *pdev)
 452 {
 453         struct rcar_gen4_pcie *rcar;
 454         int err;
 455
 456         rcar = rcar_gen4_pcie_alloc(pdev);
 457         if (IS_ERR(rcar))
 458                 return PTR_ERR(rcar);
 459
 460         err = rcar_gen4_pcie_get_resources(rcar);
 461         if (err)
 462                 return err;
 463
 464         err = rcar_gen4_pcie_prepare(rcar);
 465         if (err)
 466                 return err;
 467
 468         err = rcar_gen4_add_dw_pcie(rcar);
 469         if (err)
 470                 goto err_unprepare;
 471
 472         return 0;
 473
 474 err_unprepare:
 475         rcar_gen4_pcie_unprepare(rcar);
 476
 477         return err;
 478 }
 479
 480 static void rcar_gen4_remove_dw_pcie(struct rcar_gen4_pcie *rcar)
 481 {
 482         switch (rcar->mode) {
 483         case DW_PCIE_RC_TYPE:
 484                 rcar_gen4_remove_dw_pcie_rp(rcar);
 485                 break;
 486         case DW_PCIE_EP_TYPE:
 487                 rcar_gen4_remove_dw_pcie_ep(rcar);
 488                 break;
 489         default:
 490                 break;
 491         }
 492 }
 493
 494 static void rcar_gen4_pcie_remove(struct platform_device *pdev)
 495 {
 496         struct rcar_gen4_pcie *rcar = platform_get_drvdata(pdev);
 497
 498         rcar_gen4_remove_dw_pcie(rcar);
 499         rcar_gen4_pcie_unprepare(rcar);
 500 }
 501
 502 static const struct of_device_id rcar_gen4_pcie_of_match[] = {
 503         {
 504                 .compatible = "renesas,rcar-gen4-pcie",
 505                 .data = (void *)DW_PCIE_RC_TYPE,
 506         },
 507         {
 508                 .compatible = "renesas,rcar-gen4-pcie-ep",
 509                 .data = (void *)DW_PCIE_EP_TYPE,
 510         },
 511         {},
 512 };
 513 MODULE_DEVICE_TABLE(of, rcar_gen4_pcie_of_match);
 514
 515 static struct platform_driver rcar_gen4_pcie_driver = {
 516         .driver = {
 517                 .name = "pcie-rcar-gen4",
 518                 .of_match_table = rcar_gen4_pcie_of_match,
 519                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 520         },
 521         .probe = rcar_gen4_pcie_probe,
 522         .remove_new = rcar_gen4_pcie_remove,
 523 };
 524 module_platform_driver(rcar_gen4_pcie_driver);
 525
 526 MODULE_DESCRIPTION("Renesas R-Car Gen4 PCIe controller driver");
 527 MODULE_LICENSE("GPL");