drivers/pci/controller/dwc/pcie-qcom.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Qualcomm PCIe root complex driver
   4  *
   5  * Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
   6  * Copyright 2015 Linaro Limited.
   7  *
   8  * Author: Stanimir Varbanov <svarbanov@mm-sol.com>
   9  */
  10
  11 #include <linux/clk.h>
  12 #include <linux/delay.h>
  13 #include <linux/gpio/consumer.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/io.h>
  16 #include <linux/iopoll.h>
  17 #include <linux/kernel.h>
  18 #include <linux/init.h>
  19 #include <linux/of_device.h>
  20 #include <linux/of_gpio.h>
  21 #include <linux/pci.h>
  22 #include <linux/pm_runtime.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/phy/phy.h>
  25 #include <linux/regulator/consumer.h>
  26 #include <linux/reset.h>
  27 #include <linux/slab.h>
  28 #include <linux/types.h>
  29
  30 #include "pcie-designware.h"
  31
  32 #define PCIE20_PARF_SYS_CTRL                    0x00
  33 #define MST_WAKEUP_EN                           BIT(13)
  34 #define SLV_WAKEUP_EN                           BIT(12)
  35 #define MSTR_ACLK_CGC_DIS                       BIT(10)
  36 #define SLV_ACLK_CGC_DIS                        BIT(9)
  37 #define CORE_CLK_CGC_DIS                        BIT(6)
  38 #define AUX_PWR_DET                             BIT(4)
  39 #define L23_CLK_RMV_DIS                         BIT(2)
  40 #define L1_CLK_RMV_DIS                          BIT(1)
  41
  42 #define PCIE20_COMMAND_STATUS                   0x04
  43 #define CMD_BME_VAL                             0x4
  44 #define PCIE20_DEVICE_CONTROL2_STATUS2          0x98
  45 #define PCIE_CAP_CPL_TIMEOUT_DISABLE            0x10
  46
  47 #define PCIE20_PARF_PHY_CTRL                    0x40
  48 #define PCIE20_PARF_PHY_REFCLK                  0x4C
  49 #define PCIE20_PARF_DBI_BASE_ADDR               0x168
  50 #define PCIE20_PARF_SLV_ADDR_SPACE_SIZE         0x16C
  51 #define PCIE20_PARF_MHI_CLOCK_RESET_CTRL        0x174
  52 #define PCIE20_PARF_AXI_MSTR_WR_ADDR_HALT       0x178
  53 #define PCIE20_PARF_AXI_MSTR_WR_ADDR_HALT_V2    0x1A8
  54 #define PCIE20_PARF_LTSSM                       0x1B0
  55 #define PCIE20_PARF_SID_OFFSET                  0x234
  56 #define PCIE20_PARF_BDF_TRANSLATE_CFG           0x24C
  57 #define PCIE20_PARF_DEVICE_TYPE                 0x1000
  58
  59 #define PCIE20_ELBI_SYS_CTRL                    0x04
  60 #define PCIE20_ELBI_SYS_CTRL_LT_ENABLE          BIT(0)
  61
  62 #define PCIE20_AXI_MSTR_RESP_COMP_CTRL0         0x818
  63 #define CFG_REMOTE_RD_REQ_BRIDGE_SIZE_2K        0x4
  64 #define CFG_REMOTE_RD_REQ_BRIDGE_SIZE_4K        0x5
  65 #define PCIE20_AXI_MSTR_RESP_COMP_CTRL1         0x81c
  66 #define CFG_BRIDGE_SB_INIT                      BIT(0)
  67
  68 #define PCIE20_CAP                              0x70
  69 #define PCIE20_CAP_LINK_CAPABILITIES            (PCIE20_CAP + 0xC)
  70 #define PCIE20_CAP_ACTIVE_STATE_LINK_PM_SUPPORT (BIT(10) | BIT(11))
  71 #define PCIE20_CAP_LINK_1                       (PCIE20_CAP + 0x14)
  72 #define PCIE_CAP_LINK1_VAL                      0x2FD7F
  73
  74 #define PCIE20_PARF_Q2A_FLUSH                   0x1AC
  75
  76 #define PCIE20_MISC_CONTROL_1_REG               0x8BC
  77 #define DBI_RO_WR_EN                            1
  78
  79 #define PERST_DELAY_US                          1000
  80
  81 #define PCIE20_v3_PARF_SLV_ADDR_SPACE_SIZE      0x358
  82 #define SLV_ADDR_SPACE_SZ                       0x10000000
  83
  84 #define DEVICE_TYPE_RC                          0x4
  85
  86 #define QCOM_PCIE_2_1_0_MAX_SUPPLY      3
  87 #define QCOM_PCIE_2_1_0_MAX_CLOCKS      5
  88 struct qcom_pcie_resources_2_1_0 {
  89         struct clk_bulk_data clks[QCOM_PCIE_2_1_0_MAX_CLOCKS];
  90         struct reset_control *pci_reset;
  91         struct reset_control *axi_reset;
  92         struct reset_control *ahb_reset;
  93         struct reset_control *por_reset;
  94         struct reset_control *phy_reset;
  95         struct reset_control *ext_reset;
  96         struct regulator_bulk_data supplies[QCOM_PCIE_2_1_0_MAX_SUPPLY];
  97 };
  98
  99 struct qcom_pcie_resources_1_0_0 {
 100         struct clk *iface;
 101         struct clk *aux;
 102         struct clk *master_bus;
 103         struct clk *slave_bus;
 104         struct reset_control *core;
 105         struct regulator *vdda;
 106 };
 107
 108 #define QCOM_PCIE_2_3_2_MAX_SUPPLY      2
 109 struct qcom_pcie_resources_2_3_2 {
 110         struct clk *aux_clk;
 111         struct clk *master_clk;
 112         struct clk *slave_clk;
 113         struct clk *cfg_clk;
 114         struct clk *pipe_clk;
 115         struct regulator_bulk_data supplies[QCOM_PCIE_2_3_2_MAX_SUPPLY];
 116 };
 117
 118 #define QCOM_PCIE_2_4_0_MAX_CLOCKS      4
 119 struct qcom_pcie_resources_2_4_0 {
 120         struct clk_bulk_data clks[QCOM_PCIE_2_4_0_MAX_CLOCKS];
 121         int num_clks;
 122         struct reset_control *axi_m_reset;
 123         struct reset_control *axi_s_reset;
 124         struct reset_control *pipe_reset;
 125         struct reset_control *axi_m_vmid_reset;
 126         struct reset_control *axi_s_xpu_reset;
 127         struct reset_control *parf_reset;
 128         struct reset_control *phy_reset;
 129         struct reset_control *axi_m_sticky_reset;
 130         struct reset_control *pipe_sticky_reset;
 131         struct reset_control *pwr_reset;
 132         struct reset_control *ahb_reset;
 133         struct reset_control *phy_ahb_reset;
 134 };
 135
 136 struct qcom_pcie_resources_2_3_3 {
 137         struct clk *iface;
 138         struct clk *axi_m_clk;
 139         struct clk *axi_s_clk;
 140         struct clk *ahb_clk;
 141         struct clk *aux_clk;
 142         struct reset_control *rst[7];
 143 };
 144
 145 struct qcom_pcie_resources_2_7_0 {
 146         struct clk_bulk_data clks[6];
 147         struct regulator_bulk_data supplies[2];
 148         struct reset_control *pci_reset;
 149         struct clk *pipe_clk;
 150 };
 151
 152 union qcom_pcie_resources {
 153         struct qcom_pcie_resources_1_0_0 v1_0_0;
 154         struct qcom_pcie_resources_2_1_0 v2_1_0;
 155         struct qcom_pcie_resources_2_3_2 v2_3_2;
 156         struct qcom_pcie_resources_2_3_3 v2_3_3;
 157         struct qcom_pcie_resources_2_4_0 v2_4_0;
 158         struct qcom_pcie_resources_2_7_0 v2_7_0;
 159 };
 160
 161 struct qcom_pcie;
 162
 163 struct qcom_pcie_ops {
 164         int (*get_resources)(struct qcom_pcie *pcie);
 165         int (*init)(struct qcom_pcie *pcie);
 166         int (*post_init)(struct qcom_pcie *pcie);
 167         void (*deinit)(struct qcom_pcie *pcie);
 168         void (*post_deinit)(struct qcom_pcie *pcie);
 169         void (*ltssm_enable)(struct qcom_pcie *pcie);
 170 };
 171
 172 struct qcom_pcie {
 173         struct dw_pcie *pci;
 174         void __iomem *parf;                     /* DT parf */
 175         void __iomem *elbi;                     /* DT elbi */
 176         union qcom_pcie_resources res;
 177         struct phy *phy;
 178         struct gpio_desc *reset;
 179         const struct qcom_pcie_ops *ops;
 180 };
 181
 182 #define to_qcom_pcie(x)         dev_get_drvdata((x)->dev)
 183
 184 static void qcom_ep_reset_assert(struct qcom_pcie *pcie)
 185 {
 186         gpiod_set_value_cansleep(pcie->reset, 1);
 187         usleep_range(PERST_DELAY_US, PERST_DELAY_US + 500);
 188 }
 189
 190 static void qcom_ep_reset_deassert(struct qcom_pcie *pcie)
 191 {
 192         /* Ensure that PERST has been asserted for at least 100 ms */
 193         msleep(100);
 194         gpiod_set_value_cansleep(pcie->reset, 0);
 195         usleep_range(PERST_DELAY_US, PERST_DELAY_US + 500);
 196 }
 197
 198 static int qcom_pcie_establish_link(struct qcom_pcie *pcie)
 199 {
 200         struct dw_pcie *pci = pcie->pci;
 201
 202         if (dw_pcie_link_up(pci))
 203                 return 0;
 204
 205         /* Enable Link Training state machine */
 206         if (pcie->ops->ltssm_enable)
 207                 pcie->ops->ltssm_enable(pcie);
 208
 209         return dw_pcie_wait_for_link(pci);
 210 }
 211
 212 static void qcom_pcie_2_1_0_ltssm_enable(struct qcom_pcie *pcie)
 213 {
 214         u32 val;
 215
 216         /* enable link training */
 217         val = readl(pcie->elbi + PCIE20_ELBI_SYS_CTRL);
 218         val |= PCIE20_ELBI_SYS_CTRL_LT_ENABLE;
 219         writel(val, pcie->elbi + PCIE20_ELBI_SYS_CTRL);
 220 }
 221
 222 static int qcom_pcie_get_resources_2_1_0(struct qcom_pcie *pcie)
 223 {
 224         struct qcom_pcie_resources_2_1_0 *res = &pcie->res.v2_1_0;
 225         struct dw_pcie *pci = pcie->pci;
 226         struct device *dev = pci->dev;
 227         int ret;
 228
 229         res->supplies[0].supply = "vdda";
 230         res->supplies[1].supply = "vdda_phy";
 231         res->supplies[2].supply = "vdda_refclk";
 232         ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(res->supplies),
 233                                       res->supplies);
 234         if (ret)
 235                 return ret;
 236
 237         res->clks[0].id = "iface";
 238         res->clks[1].id = "core";
 239         res->clks[2].id = "phy";
 240         res->clks[3].id = "aux";
 241         res->clks[4].id = "ref";
 242
 243         /* iface, core, phy are required */
 244         ret = devm_clk_bulk_get(dev, 3, res->clks);
 245         if (ret < 0)
 246                 return ret;
 247
 248         /* aux, ref are optional */
 249         ret = devm_clk_bulk_get_optional(dev, 2, res->clks + 3);
 250         if (ret < 0)
 251                 return ret;
 252
 253         res->pci_reset = devm_reset_control_get_exclusive(dev, "pci");
 254         if (IS_ERR(res->pci_reset))
 255                 return PTR_ERR(res->pci_reset);
 256
 257         res->axi_reset = devm_reset_control_get_exclusive(dev, "axi");
 258         if (IS_ERR(res->axi_reset))
 259                 return PTR_ERR(res->axi_reset);
 260
 261         res->ahb_reset = devm_reset_control_get_exclusive(dev, "ahb");
 262         if (IS_ERR(res->ahb_reset))
 263                 return PTR_ERR(res->ahb_reset);
 264
 265         res->por_reset = devm_reset_control_get_exclusive(dev, "por");
 266         if (IS_ERR(res->por_reset))
 267                 return PTR_ERR(res->por_reset);
 268
 269         res->ext_reset = devm_reset_control_get_optional_exclusive(dev, "ext");
 270         if (IS_ERR(res->ext_reset))
 271                 return PTR_ERR(res->ext_reset);
 272
 273         res->phy_reset = devm_reset_control_get_exclusive(dev, "phy");
 274         return PTR_ERR_OR_ZERO(res->phy_reset);
 275 }
 276
 277 static void qcom_pcie_deinit_2_1_0(struct qcom_pcie *pcie)
 278 {
 279         struct qcom_pcie_resources_2_1_0 *res = &pcie->res.v2_1_0;
 280
 281         clk_bulk_disable_unprepare(ARRAY_SIZE(res->clks), res->clks);
 282         reset_control_assert(res->pci_reset);
 283         reset_control_assert(res->axi_reset);
 284         reset_control_assert(res->ahb_reset);
 285         reset_control_assert(res->por_reset);
 286         reset_control_assert(res->ext_reset);
 287         reset_control_assert(res->phy_reset);
 288         regulator_bulk_disable(ARRAY_SIZE(res->supplies), res->supplies);
 289 }
 290
 291 static int qcom_pcie_init_2_1_0(struct qcom_pcie *pcie)
 292 {
 293         struct qcom_pcie_resources_2_1_0 *res = &pcie->res.v2_1_0;
 294         struct dw_pcie *pci = pcie->pci;
 295         struct device *dev = pci->dev;
 296         u32 val;
 297         int ret;
 298
 299         ret = regulator_bulk_enable(ARRAY_SIZE(res->supplies), res->supplies);
 300         if (ret < 0) {
 301                 dev_err(dev, "cannot enable regulators\n");
 302                 return ret;
 303         }
 304
 305         ret = reset_control_deassert(res->ahb_reset);
 306         if (ret) {
 307                 dev_err(dev, "cannot deassert ahb reset\n");
 308                 goto err_deassert_ahb;
 309         }
 310
 311         ret = reset_control_deassert(res->ext_reset);
 312         if (ret) {
 313                 dev_err(dev, "cannot deassert ext reset\n");
 314                 goto err_deassert_ext;
 315         }
 316
 317         ret = reset_control_deassert(res->phy_reset);
 318         if (ret) {
 319                 dev_err(dev, "cannot deassert phy reset\n");
 320                 goto err_deassert_phy;
 321         }
 322
 323         ret = reset_control_deassert(res->pci_reset);
 324         if (ret) {
 325                 dev_err(dev, "cannot deassert pci reset\n");
 326                 goto err_deassert_pci;
 327         }
 328
 329         ret = reset_control_deassert(res->por_reset);
 330         if (ret) {
 331                 dev_err(dev, "cannot deassert por reset\n");
 332                 goto err_deassert_por;
 333         }
 334
 335         ret = reset_control_deassert(res->axi_reset);
 336         if (ret) {
 337                 dev_err(dev, "cannot deassert axi reset\n");
 338                 goto err_deassert_axi;
 339         }
 340
 341         ret = clk_bulk_prepare_enable(ARRAY_SIZE(res->clks), res->clks);
 342         if (ret)
 343                 goto err_clks;
 344
 345         /* enable PCIe clocks and resets */
 346         val = readl(pcie->parf + PCIE20_PARF_PHY_CTRL);
 347         val &= ~BIT(0);
 348         writel(val, pcie->parf + PCIE20_PARF_PHY_CTRL);
 349
 350         /* enable external reference clock */
 351         val = readl(pcie->parf + PCIE20_PARF_PHY_REFCLK);
 352         val |= BIT(16);
 353         writel(val, pcie->parf + PCIE20_PARF_PHY_REFCLK);
 354
 355         /* wait for clock acquisition */
 356         usleep_range(1000, 1500);
 357
 358
 359         /* Set the Max TLP size to 2K, instead of using default of 4K */
 360         writel(CFG_REMOTE_RD_REQ_BRIDGE_SIZE_2K,
 361                pci->dbi_base + PCIE20_AXI_MSTR_RESP_COMP_CTRL0);
 362         writel(CFG_BRIDGE_SB_INIT,
 363                pci->dbi_base + PCIE20_AXI_MSTR_RESP_COMP_CTRL1);
 364
 365         return 0;
 366
 367 err_clks:
 368         reset_control_assert(res->axi_reset);
 369 err_deassert_axi:
 370         reset_control_assert(res->por_reset);
 371 err_deassert_por:
 372         reset_control_assert(res->pci_reset);
 373 err_deassert_pci:
 374         reset_control_assert(res->phy_reset);
 375 err_deassert_phy:
 376         reset_control_assert(res->ext_reset);
 377 err_deassert_ext:
 378         reset_control_assert(res->ahb_reset);
 379 err_deassert_ahb:
 380         regulator_bulk_disable(ARRAY_SIZE(res->supplies), res->supplies);
 381
 382         return ret;
 383 }
 384
 385 static int qcom_pcie_get_resources_1_0_0(struct qcom_pcie *pcie)
 386 {
 387         struct qcom_pcie_resources_1_0_0 *res = &pcie->res.v1_0_0;
 388         struct dw_pcie *pci = pcie->pci;
 389         struct device *dev = pci->dev;
 390
 391         res->vdda = devm_regulator_get(dev, "vdda");
 392         if (IS_ERR(res->vdda))
 393                 return PTR_ERR(res->vdda);
 394
 395         res->iface = devm_clk_get(dev, "iface");
 396         if (IS_ERR(res->iface))
 397                 return PTR_ERR(res->iface);
 398
 399         res->aux = devm_clk_get(dev, "aux");
 400         if (IS_ERR(res->aux))
 401                 return PTR_ERR(res->aux);
 402
 403         res->master_bus = devm_clk_get(dev, "master_bus");
 404         if (IS_ERR(res->master_bus))
 405                 return PTR_ERR(res->master_bus);
 406
 407         res->slave_bus = devm_clk_get(dev, "slave_bus");
 408         if (IS_ERR(res->slave_bus))
 409                 return PTR_ERR(res->slave_bus);
 410
 411         res->core = devm_reset_control_get_exclusive(dev, "core");
 412         return PTR_ERR_OR_ZERO(res->core);
 413 }
 414
 415 static void qcom_pcie_deinit_1_0_0(struct qcom_pcie *pcie)
 416 {
 417         struct qcom_pcie_resources_1_0_0 *res = &pcie->res.v1_0_0;
 418
 419         reset_control_assert(res->core);
 420         clk_disable_unprepare(res->slave_bus);
 421         clk_disable_unprepare(res->master_bus);
 422         clk_disable_unprepare(res->iface);
 423         clk_disable_unprepare(res->aux);
 424         regulator_disable(res->vdda);
 425 }
 426
 427 static int qcom_pcie_init_1_0_0(struct qcom_pcie *pcie)
 428 {
 429         struct qcom_pcie_resources_1_0_0 *res = &pcie->res.v1_0_0;
 430         struct dw_pcie *pci = pcie->pci;
 431         struct device *dev = pci->dev;
 432         int ret;
 433
 434         ret = reset_control_deassert(res->core);
 435         if (ret) {
 436                 dev_err(dev, "cannot deassert core reset\n");
 437                 return ret;
 438         }
 439
 440         ret = clk_prepare_enable(res->aux);
 441         if (ret) {
 442                 dev_err(dev, "cannot prepare/enable aux clock\n");
 443                 goto err_res;
 444         }
 445
 446         ret = clk_prepare_enable(res->iface);
 447         if (ret) {
 448                 dev_err(dev, "cannot prepare/enable iface clock\n");
 449                 goto err_aux;
 450         }
 451
 452         ret = clk_prepare_enable(res->master_bus);
 453         if (ret) {
 454                 dev_err(dev, "cannot prepare/enable master_bus clock\n");
 455                 goto err_iface;
 456         }
 457
 458         ret = clk_prepare_enable(res->slave_bus);
 459         if (ret) {
 460                 dev_err(dev, "cannot prepare/enable slave_bus clock\n");
 461                 goto err_master;
 462         }
 463
 464         ret = regulator_enable(res->vdda);
 465         if (ret) {
 466                 dev_err(dev, "cannot enable vdda regulator\n");
 467                 goto err_slave;
 468         }
 469
 470         /* change DBI base address */
 471         writel(0, pcie->parf + PCIE20_PARF_DBI_BASE_ADDR);
 472
 473         if (IS_ENABLED(CONFIG_PCI_MSI)) {
 474                 u32 val = readl(pcie->parf + PCIE20_PARF_AXI_MSTR_WR_ADDR_HALT);
 475
 476                 val |= BIT(31);
 477                 writel(val, pcie->parf + PCIE20_PARF_AXI_MSTR_WR_ADDR_HALT);
 478         }
 479
 480         return 0;
 481 err_slave:
 482         clk_disable_unprepare(res->slave_bus);
 483 err_master:
 484         clk_disable_unprepare(res->master_bus);
 485 err_iface:
 486         clk_disable_unprepare(res->iface);
 487 err_aux:
 488         clk_disable_unprepare(res->aux);
 489 err_res:
 490         reset_control_assert(res->core);
 491
 492         return ret;
 493 }
 494
 495 static void qcom_pcie_2_3_2_ltssm_enable(struct qcom_pcie *pcie)
 496 {
 497         u32 val;
 498
 499         /* enable link training */
 500         val = readl(pcie->parf + PCIE20_PARF_LTSSM);
 501         val |= BIT(8);
 502         writel(val, pcie->parf + PCIE20_PARF_LTSSM);
 503 }
 504
 505 static int qcom_pcie_get_resources_2_3_2(struct qcom_pcie *pcie)
 506 {
 507         struct qcom_pcie_resources_2_3_2 *res = &pcie->res.v2_3_2;
 508         struct dw_pcie *pci = pcie->pci;
 509         struct device *dev = pci->dev;
 510         int ret;
 511
 512         res->supplies[0].supply = "vdda";
 513         res->supplies[1].supply = "vddpe-3v3";
 514         ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(res->supplies),
 515                                       res->supplies);
 516         if (ret)
 517                 return ret;
 518
 519         res->aux_clk = devm_clk_get(dev, "aux");
 520         if (IS_ERR(res->aux_clk))
 521                 return PTR_ERR(res->aux_clk);
 522
 523         res->cfg_clk = devm_clk_get(dev, "cfg");
 524         if (IS_ERR(res->cfg_clk))
 525                 return PTR_ERR(res->cfg_clk);
 526
 527         res->master_clk = devm_clk_get(dev, "bus_master");
 528         if (IS_ERR(res->master_clk))
 529                 return PTR_ERR(res->master_clk);
 530
 531         res->slave_clk = devm_clk_get(dev, "bus_slave");
 532         if (IS_ERR(res->slave_clk))
 533                 return PTR_ERR(res->slave_clk);
 534
 535         res->pipe_clk = devm_clk_get(dev, "pipe");
 536         return PTR_ERR_OR_ZERO(res->pipe_clk);
 537 }
 538
 539 static void qcom_pcie_deinit_2_3_2(struct qcom_pcie *pcie)
 540 {
 541         struct qcom_pcie_resources_2_3_2 *res = &pcie->res.v2_3_2;
 542
 543         clk_disable_unprepare(res->slave_clk);
 544         clk_disable_unprepare(res->master_clk);
 545         clk_disable_unprepare(res->cfg_clk);
 546         clk_disable_unprepare(res->aux_clk);
 547
 548         regulator_bulk_disable(ARRAY_SIZE(res->supplies), res->supplies);
 549 }
 550
 551 static void qcom_pcie_post_deinit_2_3_2(struct qcom_pcie *pcie)
 552 {
 553         struct qcom_pcie_resources_2_3_2 *res = &pcie->res.v2_3_2;
 554
 555         clk_disable_unprepare(res->pipe_clk);
 556 }
 557
 558 static int qcom_pcie_init_2_3_2(struct qcom_pcie *pcie)
 559 {
 560         struct qcom_pcie_resources_2_3_2 *res = &pcie->res.v2_3_2;
 561         struct dw_pcie *pci = pcie->pci;
 562         struct device *dev = pci->dev;
 563         u32 val;
 564         int ret;
 565
 566         ret = regulator_bulk_enable(ARRAY_SIZE(res->supplies), res->supplies);
 567         if (ret < 0) {
 568                 dev_err(dev, "cannot enable regulators\n");
 569                 return ret;
 570         }
 571
 572         ret = clk_prepare_enable(res->aux_clk);
 573         if (ret) {
 574                 dev_err(dev, "cannot prepare/enable aux clock\n");
 575                 goto err_aux_clk;
 576         }
 577
 578         ret = clk_prepare_enable(res->cfg_clk);
 579         if (ret) {
 580                 dev_err(dev, "cannot prepare/enable cfg clock\n");
 581                 goto err_cfg_clk;
 582         }
 583
 584         ret = clk_prepare_enable(res->master_clk);
 585         if (ret) {
 586                 dev_err(dev, "cannot prepare/enable master clock\n");
 587                 goto err_master_clk;
 588         }
 589
 590         ret = clk_prepare_enable(res->slave_clk);
 591         if (ret) {
 592                 dev_err(dev, "cannot prepare/enable slave clock\n");
 593                 goto err_slave_clk;
 594         }
 595
 596         /* enable PCIe clocks and resets */
 597         val = readl(pcie->parf + PCIE20_PARF_PHY_CTRL);
 598         val &= ~BIT(0);
 599         writel(val, pcie->parf + PCIE20_PARF_PHY_CTRL);
 600
 601         /* change DBI base address */
 602         writel(0, pcie->parf + PCIE20_PARF_DBI_BASE_ADDR);
 603
 604         /* MAC PHY_POWERDOWN MUX DISABLE  */
 605         val = readl(pcie->parf + PCIE20_PARF_SYS_CTRL);
 606         val &= ~BIT(29);
 607         writel(val, pcie->parf + PCIE20_PARF_SYS_CTRL);
 608
 609         val = readl(pcie->parf + PCIE20_PARF_MHI_CLOCK_RESET_CTRL);
 610         val |= BIT(4);
 611         writel(val, pcie->parf + PCIE20_PARF_MHI_CLOCK_RESET_CTRL);
 612
 613         val = readl(pcie->parf + PCIE20_PARF_AXI_MSTR_WR_ADDR_HALT_V2);
 614         val |= BIT(31);
 615         writel(val, pcie->parf + PCIE20_PARF_AXI_MSTR_WR_ADDR_HALT_V2);
 616
 617         return 0;
 618
 619 err_slave_clk:
 620         clk_disable_unprepare(res->master_clk);
 621 err_master_clk:
 622         clk_disable_unprepare(res->cfg_clk);
 623 err_cfg_clk:
 624         clk_disable_unprepare(res->aux_clk);
 625
 626 err_aux_clk:
 627         regulator_bulk_disable(ARRAY_SIZE(res->supplies), res->supplies);
 628
 629         return ret;
 630 }
 631
 632 static int qcom_pcie_post_init_2_3_2(struct qcom_pcie *pcie)
 633 {
 634         struct qcom_pcie_resources_2_3_2 *res = &pcie->res.v2_3_2;
 635         struct dw_pcie *pci = pcie->pci;
 636         struct device *dev = pci->dev;
 637         int ret;
 638
 639         ret = clk_prepare_enable(res->pipe_clk);
 640         if (ret) {
 641                 dev_err(dev, "cannot prepare/enable pipe clock\n");
 642                 return ret;
 643         }
 644
 645         return 0;
 646 }
 647
 648 static int qcom_pcie_get_resources_2_4_0(struct qcom_pcie *pcie)
 649 {
 650         struct qcom_pcie_resources_2_4_0 *res = &pcie->res.v2_4_0;
 651         struct dw_pcie *pci = pcie->pci;
 652         struct device *dev = pci->dev;
 653         bool is_ipq = of_device_is_compatible(dev->of_node, "qcom,pcie-ipq4019");
 654         int ret;
 655
 656         res->clks[0].id = "aux";
 657         res->clks[1].id = "master_bus";
 658         res->clks[2].id = "slave_bus";
 659         res->clks[3].id = "iface";
 660
 661         /* qcom,pcie-ipq4019 is defined without "iface" */
 662         res->num_clks = is_ipq ? 3 : 4;
 663
 664         ret = devm_clk_bulk_get(dev, res->num_clks, res->clks);
 665         if (ret < 0)
 666                 return ret;
 667
 668         res->axi_m_reset = devm_reset_control_get_exclusive(dev, "axi_m");
 669         if (IS_ERR(res->axi_m_reset))
 670                 return PTR_ERR(res->axi_m_reset);
 671
 672         res->axi_s_reset = devm_reset_control_get_exclusive(dev, "axi_s");
 673         if (IS_ERR(res->axi_s_reset))
 674                 return PTR_ERR(res->axi_s_reset);
 675
 676         if (is_ipq) {
 677                 /*
 678                  * These resources relates to the PHY or are secure clocks, but
 679                  * are controlled here for IPQ4019
 680                  */
 681                 res->pipe_reset = devm_reset_control_get_exclusive(dev, "pipe");
 682                 if (IS_ERR(res->pipe_reset))
 683                         return PTR_ERR(res->pipe_reset);
 684
 685                 res->axi_m_vmid_reset = devm_reset_control_get_exclusive(dev,
 686                                                                          "axi_m_vmid");
 687                 if (IS_ERR(res->axi_m_vmid_reset))
 688                         return PTR_ERR(res->axi_m_vmid_reset);
 689
 690                 res->axi_s_xpu_reset = devm_reset_control_get_exclusive(dev,
 691                                                                         "axi_s_xpu");
 692                 if (IS_ERR(res->axi_s_xpu_reset))
 693                         return PTR_ERR(res->axi_s_xpu_reset);
 694
 695                 res->parf_reset = devm_reset_control_get_exclusive(dev, "parf");
 696                 if (IS_ERR(res->parf_reset))
 697                         return PTR_ERR(res->parf_reset);
 698
 699                 res->phy_reset = devm_reset_control_get_exclusive(dev, "phy");
 700                 if (IS_ERR(res->phy_reset))
 701                         return PTR_ERR(res->phy_reset);
 702         }
 703
 704         res->axi_m_sticky_reset = devm_reset_control_get_exclusive(dev,
 705                                                                    "axi_m_sticky");
 706         if (IS_ERR(res->axi_m_sticky_reset))
 707                 return PTR_ERR(res->axi_m_sticky_reset);
 708
 709         res->pipe_sticky_reset = devm_reset_control_get_exclusive(dev,
 710                                                                   "pipe_sticky");
 711         if (IS_ERR(res->pipe_sticky_reset))
 712                 return PTR_ERR(res->pipe_sticky_reset);
 713
 714         res->pwr_reset = devm_reset_control_get_exclusive(dev, "pwr");
 715         if (IS_ERR(res->pwr_reset))
 716                 return PTR_ERR(res->pwr_reset);
 717
 718         res->ahb_reset = devm_reset_control_get_exclusive(dev, "ahb");
 719         if (IS_ERR(res->ahb_reset))
 720                 return PTR_ERR(res->ahb_reset);
 721
 722         if (is_ipq) {
 723                 res->phy_ahb_reset = devm_reset_control_get_exclusive(dev, "phy_ahb");
 724                 if (IS_ERR(res->phy_ahb_reset))
 725                         return PTR_ERR(res->phy_ahb_reset);
 726         }
 727
 728         return 0;
 729 }
 730
 731 static void qcom_pcie_deinit_2_4_0(struct qcom_pcie *pcie)
 732 {
 733         struct qcom_pcie_resources_2_4_0 *res = &pcie->res.v2_4_0;
 734
 735         reset_control_assert(res->axi_m_reset);
 736         reset_control_assert(res->axi_s_reset);
 737         reset_control_assert(res->pipe_reset);
 738         reset_control_assert(res->pipe_sticky_reset);
 739         reset_control_assert(res->phy_reset);
 740         reset_control_assert(res->phy_ahb_reset);
 741         reset_control_assert(res->axi_m_sticky_reset);
 742         reset_control_assert(res->pwr_reset);
 743         reset_control_assert(res->ahb_reset);
 744         clk_bulk_disable_unprepare(res->num_clks, res->clks);
 745 }
 746
 747 static int qcom_pcie_init_2_4_0(struct qcom_pcie *pcie)
 748 {
 749         struct qcom_pcie_resources_2_4_0 *res = &pcie->res.v2_4_0;
 750         struct dw_pcie *pci = pcie->pci;
 751         struct device *dev = pci->dev;
 752         u32 val;
 753         int ret;
 754
 755         ret = reset_control_assert(res->axi_m_reset);
 756         if (ret) {
 757                 dev_err(dev, "cannot assert axi master reset\n");
 758                 return ret;
 759         }
 760
 761         ret = reset_control_assert(res->axi_s_reset);
 762         if (ret) {
 763                 dev_err(dev, "cannot assert axi slave reset\n");
 764                 return ret;
 765         }
 766
 767         usleep_range(10000, 12000);
 768
 769         ret = reset_control_assert(res->pipe_reset);
 770         if (ret) {
 771                 dev_err(dev, "cannot assert pipe reset\n");
 772                 return ret;
 773         }
 774
 775         ret = reset_control_assert(res->pipe_sticky_reset);
 776         if (ret) {
 777                 dev_err(dev, "cannot assert pipe sticky reset\n");
 778                 return ret;
 779         }
 780
 781         ret = reset_control_assert(res->phy_reset);
 782         if (ret) {
 783                 dev_err(dev, "cannot assert phy reset\n");
 784                 return ret;
 785         }
 786
 787         ret = reset_control_assert(res->phy_ahb_reset);
 788         if (ret) {
 789                 dev_err(dev, "cannot assert phy ahb reset\n");
 790                 return ret;
 791         }
 792
 793         usleep_range(10000, 12000);
 794
 795         ret = reset_control_assert(res->axi_m_sticky_reset);
 796         if (ret) {
 797                 dev_err(dev, "cannot assert axi master sticky reset\n");
 798                 return ret;
 799         }
 800
 801         ret = reset_control_assert(res->pwr_reset);
 802         if (ret) {
 803                 dev_err(dev, "cannot assert power reset\n");
 804                 return ret;
 805         }
 806
 807         ret = reset_control_assert(res->ahb_reset);
 808         if (ret) {
 809                 dev_err(dev, "cannot assert ahb reset\n");
 810                 return ret;
 811         }
 812
 813         usleep_range(10000, 12000);
 814
 815         ret = reset_control_deassert(res->phy_ahb_reset);
 816         if (ret) {
 817                 dev_err(dev, "cannot deassert phy ahb reset\n");
 818                 return ret;
 819         }
 820
 821         ret = reset_control_deassert(res->phy_reset);
 822         if (ret) {
 823                 dev_err(dev, "cannot deassert phy reset\n");
 824                 goto err_rst_phy;
 825         }
 826
 827         ret = reset_control_deassert(res->pipe_reset);
 828         if (ret) {
 829                 dev_err(dev, "cannot deassert pipe reset\n");
 830                 goto err_rst_pipe;
 831         }
 832
 833         ret = reset_control_deassert(res->pipe_sticky_reset);
 834         if (ret) {
 835                 dev_err(dev, "cannot deassert pipe sticky reset\n");
 836                 goto err_rst_pipe_sticky;
 837         }
 838
 839         usleep_range(10000, 12000);
 840
 841         ret = reset_control_deassert(res->axi_m_reset);
 842         if (ret) {
 843                 dev_err(dev, "cannot deassert axi master reset\n");
 844                 goto err_rst_axi_m;
 845         }
 846
 847         ret = reset_control_deassert(res->axi_m_sticky_reset);
 848         if (ret) {
 849                 dev_err(dev, "cannot deassert axi master sticky reset\n");
 850                 goto err_rst_axi_m_sticky;
 851         }
 852
 853         ret = reset_control_deassert(res->axi_s_reset);
 854         if (ret) {
 855                 dev_err(dev, "cannot deassert axi slave reset\n");
 856                 goto err_rst_axi_s;
 857         }
 858
 859         ret = reset_control_deassert(res->pwr_reset);
 860         if (ret) {
 861                 dev_err(dev, "cannot deassert power reset\n");
 862                 goto err_rst_pwr;
 863         }
 864
 865         ret = reset_control_deassert(res->ahb_reset);
 866         if (ret) {
 867                 dev_err(dev, "cannot deassert ahb reset\n");
 868                 goto err_rst_ahb;
 869         }
 870
 871         usleep_range(10000, 12000);
 872
 873         ret = clk_bulk_prepare_enable(res->num_clks, res->clks);
 874         if (ret)
 875                 goto err_clks;
 876
 877         /* enable PCIe clocks and resets */
 878         val = readl(pcie->parf + PCIE20_PARF_PHY_CTRL);
 879         val &= ~BIT(0);
 880         writel(val, pcie->parf + PCIE20_PARF_PHY_CTRL);
 881
 882         /* change DBI base address */
 883         writel(0, pcie->parf + PCIE20_PARF_DBI_BASE_ADDR);
 884
 885         /* MAC PHY_POWERDOWN MUX DISABLE  */
 886         val = readl(pcie->parf + PCIE20_PARF_SYS_CTRL);
 887         val &= ~BIT(29);
 888         writel(val, pcie->parf + PCIE20_PARF_SYS_CTRL);
 889
 890         val = readl(pcie->parf + PCIE20_PARF_MHI_CLOCK_RESET_CTRL);
 891         val |= BIT(4);
 892         writel(val, pcie->parf + PCIE20_PARF_MHI_CLOCK_RESET_CTRL);
 893
 894         val = readl(pcie->parf + PCIE20_PARF_AXI_MSTR_WR_ADDR_HALT_V2);
 895         val |= BIT(31);
 896         writel(val, pcie->parf + PCIE20_PARF_AXI_MSTR_WR_ADDR_HALT_V2);
 897
 898         return 0;
 899
 900 err_clks:
 901         reset_control_assert(res->ahb_reset);
 902 err_rst_ahb:
 903         reset_control_assert(res->pwr_reset);
 904 err_rst_pwr:
 905         reset_control_assert(res->axi_s_reset);
 906 err_rst_axi_s:
 907         reset_control_assert(res->axi_m_sticky_reset);
 908 err_rst_axi_m_sticky:
 909         reset_control_assert(res->axi_m_reset);
 910 err_rst_axi_m:
 911         reset_control_assert(res->pipe_sticky_reset);
 912 err_rst_pipe_sticky:
 913         reset_control_assert(res->pipe_reset);
 914 err_rst_pipe:
 915         reset_control_assert(res->phy_reset);
 916 err_rst_phy:
 917         reset_control_assert(res->phy_ahb_reset);
 918         return ret;
 919 }
 920
 921 static int qcom_pcie_get_resources_2_3_3(struct qcom_pcie *pcie)
 922 {
 923         struct qcom_pcie_resources_2_3_3 *res = &pcie->res.v2_3_3;
 924         struct dw_pcie *pci = pcie->pci;
 925         struct device *dev = pci->dev;
 926         int i;
 927         const char *rst_names[] = { "axi_m", "axi_s", "pipe",
 928                                     "axi_m_sticky", "sticky",
 929                                     "ahb", "sleep", };
 930
 931         res->iface = devm_clk_get(dev, "iface");
 932         if (IS_ERR(res->iface))
 933                 return PTR_ERR(res->iface);
 934
 935         res->axi_m_clk = devm_clk_get(dev, "axi_m");
 936         if (IS_ERR(res->axi_m_clk))
 937                 return PTR_ERR(res->axi_m_clk);
 938
 939         res->axi_s_clk = devm_clk_get(dev, "axi_s");
 940         if (IS_ERR(res->axi_s_clk))
 941                 return PTR_ERR(res->axi_s_clk);
 942
 943         res->ahb_clk = devm_clk_get(dev, "ahb");
 944         if (IS_ERR(res->ahb_clk))
 945                 return PTR_ERR(res->ahb_clk);
 946
 947         res->aux_clk = devm_clk_get(dev, "aux");
 948         if (IS_ERR(res->aux_clk))
 949                 return PTR_ERR(res->aux_clk);
 950
 951         for (i = 0; i < ARRAY_SIZE(rst_names); i++) {
 952                 res->rst[i] = devm_reset_control_get(dev, rst_names[i]);
 953                 if (IS_ERR(res->rst[i]))
 954                         return PTR_ERR(res->rst[i]);
 955         }
 956
 957         return 0;
 958 }
 959
 960 static void qcom_pcie_deinit_2_3_3(struct qcom_pcie *pcie)
 961 {
 962         struct qcom_pcie_resources_2_3_3 *res = &pcie->res.v2_3_3;
 963
 964         clk_disable_unprepare(res->iface);
 965         clk_disable_unprepare(res->axi_m_clk);
 966         clk_disable_unprepare(res->axi_s_clk);
 967         clk_disable_unprepare(res->ahb_clk);
 968         clk_disable_unprepare(res->aux_clk);
 969 }
 970
 971 static int qcom_pcie_init_2_3_3(struct qcom_pcie *pcie)
 972 {
 973         struct qcom_pcie_resources_2_3_3 *res = &pcie->res.v2_3_3;
 974         struct dw_pcie *pci = pcie->pci;
 975         struct device *dev = pci->dev;
 976         int i, ret;
 977         u32 val;
 978
 979         for (i = 0; i < ARRAY_SIZE(res->rst); i++) {
 980                 ret = reset_control_assert(res->rst[i]);
 981                 if (ret) {
 982                         dev_err(dev, "reset #%d assert failed (%d)\n", i, ret);
 983                         return ret;
 984                 }
 985         }
 986
 987         usleep_range(2000, 2500);
 988
 989         for (i = 0; i < ARRAY_SIZE(res->rst); i++) {
 990                 ret = reset_control_deassert(res->rst[i]);
 991                 if (ret) {
 992                         dev_err(dev, "reset #%d deassert failed (%d)\n", i,
 993                                 ret);
 994                         return ret;
 995                 }
 996         }
 997
 998         /*
 999          * Don't have a way to see if the reset has completed.
1000          * Wait for some time.
1001          */
1002         usleep_range(2000, 2500);
1003
1004         ret = clk_prepare_enable(res->iface);
1005         if (ret) {
1006                 dev_err(dev, "cannot prepare/enable core clock\n");
1007                 goto err_clk_iface;
1008         }
1009
1010         ret = clk_prepare_enable(res->axi_m_clk);
1011         if (ret) {
1012                 dev_err(dev, "cannot prepare/enable core clock\n");
1013                 goto err_clk_axi_m;
1014         }
1015
1016         ret = clk_prepare_enable(res->axi_s_clk);
1017         if (ret) {
1018                 dev_err(dev, "cannot prepare/enable axi slave clock\n");
1019                 goto err_clk_axi_s;
1020         }
1021
1022         ret = clk_prepare_enable(res->ahb_clk);
1023         if (ret) {
1024                 dev_err(dev, "cannot prepare/enable ahb clock\n");
1025                 goto err_clk_ahb;
1026         }
1027
1028         ret = clk_prepare_enable(res->aux_clk);
1029         if (ret) {
1030                 dev_err(dev, "cannot prepare/enable aux clock\n");
1031                 goto err_clk_aux;
1032         }
1033
1034         writel(SLV_ADDR_SPACE_SZ,
1035                 pcie->parf + PCIE20_v3_PARF_SLV_ADDR_SPACE_SIZE);
1036
1037         val = readl(pcie->parf + PCIE20_PARF_PHY_CTRL);
1038         val &= ~BIT(0);
1039         writel(val, pcie->parf + PCIE20_PARF_PHY_CTRL);
1040
1041         writel(0, pcie->parf + PCIE20_PARF_DBI_BASE_ADDR);
1042
1043         writel(MST_WAKEUP_EN | SLV_WAKEUP_EN | MSTR_ACLK_CGC_DIS
1044                 | SLV_ACLK_CGC_DIS | CORE_CLK_CGC_DIS |
1045                 AUX_PWR_DET | L23_CLK_RMV_DIS | L1_CLK_RMV_DIS,
1046                 pcie->parf + PCIE20_PARF_SYS_CTRL);
1047         writel(0, pcie->parf + PCIE20_PARF_Q2A_FLUSH);
1048
1049         writel(CMD_BME_VAL, pci->dbi_base + PCIE20_COMMAND_STATUS);
1050         writel(DBI_RO_WR_EN, pci->dbi_base + PCIE20_MISC_CONTROL_1_REG);
1051         writel(PCIE_CAP_LINK1_VAL, pci->dbi_base + PCIE20_CAP_LINK_1);
1052
1053         val = readl(pci->dbi_base + PCIE20_CAP_LINK_CAPABILITIES);
1054         val &= ~PCIE20_CAP_ACTIVE_STATE_LINK_PM_SUPPORT;
1055         writel(val, pci->dbi_base + PCIE20_CAP_LINK_CAPABILITIES);
1056
1057         writel(PCIE_CAP_CPL_TIMEOUT_DISABLE, pci->dbi_base +
1058                 PCIE20_DEVICE_CONTROL2_STATUS2);
1059
1060         return 0;
1061
1062 err_clk_aux:
1063         clk_disable_unprepare(res->ahb_clk);
1064 err_clk_ahb:
1065         clk_disable_unprepare(res->axi_s_clk);
1066 err_clk_axi_s:
1067         clk_disable_unprepare(res->axi_m_clk);
1068 err_clk_axi_m:
1069         clk_disable_unprepare(res->iface);
1070 err_clk_iface:
1071         /*
1072          * Not checking for failure, will anyway return
1073          * the original failure in 'ret'.
1074          */
1075         for (i = 0; i < ARRAY_SIZE(res->rst); i++)
1076                 reset_control_assert(res->rst[i]);
1077
1078         return ret;
1079 }
1080
1081 static int qcom_pcie_get_resources_2_7_0(struct qcom_pcie *pcie)
1082 {
1083         struct qcom_pcie_resources_2_7_0 *res = &pcie->res.v2_7_0;
1084         struct dw_pcie *pci = pcie->pci;
1085         struct device *dev = pci->dev;
1086         int ret;
1087
1088         res->pci_reset = devm_reset_control_get_exclusive(dev, "pci");
1089         if (IS_ERR(res->pci_reset))
1090                 return PTR_ERR(res->pci_reset);
1091
1092         res->supplies[0].supply = "vdda";
1093         res->supplies[1].supply = "vddpe-3v3";
1094         ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(res->supplies),
1095                                       res->supplies);
1096         if (ret)
1097                 return ret;
1098
1099         res->clks[0].id = "aux";
1100         res->clks[1].id = "cfg";
1101         res->clks[2].id = "bus_master";
1102         res->clks[3].id = "bus_slave";
1103         res->clks[4].id = "slave_q2a";
1104         res->clks[5].id = "tbu";
1105
1106         ret = devm_clk_bulk_get(dev, ARRAY_SIZE(res->clks), res->clks);
1107         if (ret < 0)
1108                 return ret;
1109
1110         res->pipe_clk = devm_clk_get(dev, "pipe");
1111         return PTR_ERR_OR_ZERO(res->pipe_clk);
1112 }
1113
1114 static int qcom_pcie_init_2_7_0(struct qcom_pcie *pcie)
1115 {
1116         struct qcom_pcie_resources_2_7_0 *res = &pcie->res.v2_7_0;
1117         struct dw_pcie *pci = pcie->pci;
1118         struct device *dev = pci->dev;
1119         u32 val;
1120         int ret;
1121
1122         ret = regulator_bulk_enable(ARRAY_SIZE(res->supplies), res->supplies);
1123         if (ret < 0) {
1124                 dev_err(dev, "cannot enable regulators\n");
1125                 return ret;
1126         }
1127
1128         ret = clk_bulk_prepare_enable(ARRAY_SIZE(res->clks), res->clks);
1129         if (ret < 0)
1130                 goto err_disable_regulators;
1131
1132         ret = reset_control_assert(res->pci_reset);
1133         if (ret < 0) {
1134                 dev_err(dev, "cannot deassert pci reset\n");
1135                 goto err_disable_clocks;
1136         }
1137
1138         usleep_range(1000, 1500);
1139
1140         ret = reset_control_deassert(res->pci_reset);
1141         if (ret < 0) {
1142                 dev_err(dev, "cannot deassert pci reset\n");
1143                 goto err_disable_clocks;
1144         }
1145
1146         ret = clk_prepare_enable(res->pipe_clk);
1147         if (ret) {
1148                 dev_err(dev, "cannot prepare/enable pipe clock\n");
1149                 goto err_disable_clocks;
1150         }
1151
1152         /* configure PCIe to RC mode */
1153         writel(DEVICE_TYPE_RC, pcie->parf + PCIE20_PARF_DEVICE_TYPE);
1154
1155         /* enable PCIe clocks and resets */
1156         val = readl(pcie->parf + PCIE20_PARF_PHY_CTRL);
1157         val &= ~BIT(0);
1158         writel(val, pcie->parf + PCIE20_PARF_PHY_CTRL);
1159
1160         /* change DBI base address */
1161         writel(0, pcie->parf + PCIE20_PARF_DBI_BASE_ADDR);
1162
1163         /* MAC PHY_POWERDOWN MUX DISABLE  */
1164         val = readl(pcie->parf + PCIE20_PARF_SYS_CTRL);
1165         val &= ~BIT(29);
1166         writel(val, pcie->parf + PCIE20_PARF_SYS_CTRL);
1167
1168         val = readl(pcie->parf + PCIE20_PARF_MHI_CLOCK_RESET_CTRL);
1169         val |= BIT(4);
1170         writel(val, pcie->parf + PCIE20_PARF_MHI_CLOCK_RESET_CTRL);
1171
1172         if (IS_ENABLED(CONFIG_PCI_MSI)) {
1173                 val = readl(pcie->parf + PCIE20_PARF_AXI_MSTR_WR_ADDR_HALT);
1174                 val |= BIT(31);
1175                 writel(val, pcie->parf + PCIE20_PARF_AXI_MSTR_WR_ADDR_HALT);
1176         }
1177
1178         return 0;
1179 err_disable_clocks:
1180         clk_bulk_disable_unprepare(ARRAY_SIZE(res->clks), res->clks);
1181 err_disable_regulators:
1182         regulator_bulk_disable(ARRAY_SIZE(res->supplies), res->supplies);
1183
1184         return ret;
1185 }
1186
1187 static void qcom_pcie_deinit_2_7_0(struct qcom_pcie *pcie)
1188 {
1189         struct qcom_pcie_resources_2_7_0 *res = &pcie->res.v2_7_0;
1190
1191         clk_bulk_disable_unprepare(ARRAY_SIZE(res->clks), res->clks);
1192         regulator_bulk_disable(ARRAY_SIZE(res->supplies), res->supplies);
1193 }
1194
1195 static int qcom_pcie_post_init_2_7_0(struct qcom_pcie *pcie)
1196 {
1197         struct qcom_pcie_resources_2_7_0 *res = &pcie->res.v2_7_0;
1198
1199         return clk_prepare_enable(res->pipe_clk);
1200 }
1201
1202 static void qcom_pcie_post_deinit_2_7_0(struct qcom_pcie *pcie)
1203 {
1204         struct qcom_pcie_resources_2_7_0 *res = &pcie->res.v2_7_0;
1205
1206         clk_disable_unprepare(res->pipe_clk);
1207 }
1208
1209 static int qcom_pcie_link_up(struct dw_pcie *pci)
1210 {
1211         u16 val = readw(pci->dbi_base + PCIE20_CAP + PCI_EXP_LNKSTA);
1212
1213         return !!(val & PCI_EXP_LNKSTA_DLLLA);
1214 }
1215
1216 static int qcom_pcie_host_init(struct pcie_port *pp)
1217 {
1218         struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
1219         struct qcom_pcie *pcie = to_qcom_pcie(pci);
1220         int ret;
1221
1222         qcom_ep_reset_assert(pcie);
1223
1224         ret = pcie->ops->init(pcie);
1225         if (ret)
1226                 return ret;
1227
1228         ret = phy_power_on(pcie->phy);
1229         if (ret)
1230                 goto err_deinit;
1231
1232         if (pcie->ops->post_init) {
1233                 ret = pcie->ops->post_init(pcie);
1234                 if (ret)
1235                         goto err_disable_phy;
1236         }
1237
1238         dw_pcie_setup_rc(pp);
1239
1240         if (IS_ENABLED(CONFIG_PCI_MSI))
1241                 dw_pcie_msi_init(pp);
1242
1243         qcom_ep_reset_deassert(pcie);
1244
1245         ret = qcom_pcie_establish_link(pcie);
1246         if (ret)
1247                 goto err;
1248
1249         return 0;
1250 err:
1251         qcom_ep_reset_assert(pcie);
1252         if (pcie->ops->post_deinit)
1253                 pcie->ops->post_deinit(pcie);
1254 err_disable_phy:
1255         phy_power_off(pcie->phy);
1256 err_deinit:
1257         pcie->ops->deinit(pcie);
1258
1259         return ret;
1260 }
1261
1262 static const struct dw_pcie_host_ops qcom_pcie_dw_ops = {
1263         .host_init = qcom_pcie_host_init,
1264 };
1265
1266 /* Qcom IP rev.: 2.1.0  Synopsys IP rev.: 4.01a */
1267 static const struct qcom_pcie_ops ops_2_1_0 = {
1268         .get_resources = qcom_pcie_get_resources_2_1_0,
1269         .init = qcom_pcie_init_2_1_0,
1270         .deinit = qcom_pcie_deinit_2_1_0,
1271         .ltssm_enable = qcom_pcie_2_1_0_ltssm_enable,
1272 };
1273
1274 /* Qcom IP rev.: 1.0.0  Synopsys IP rev.: 4.11a */
1275 static const struct qcom_pcie_ops ops_1_0_0 = {
1276         .get_resources = qcom_pcie_get_resources_1_0_0,
1277         .init = qcom_pcie_init_1_0_0,
1278         .deinit = qcom_pcie_deinit_1_0_0,
1279         .ltssm_enable = qcom_pcie_2_1_0_ltssm_enable,
1280 };
1281
1282 /* Qcom IP rev.: 2.3.2  Synopsys IP rev.: 4.21a */
1283 static const struct qcom_pcie_ops ops_2_3_2 = {
1284         .get_resources = qcom_pcie_get_resources_2_3_2,
1285         .init = qcom_pcie_init_2_3_2,
1286         .post_init = qcom_pcie_post_init_2_3_2,
1287         .deinit = qcom_pcie_deinit_2_3_2,
1288         .post_deinit = qcom_pcie_post_deinit_2_3_2,
1289         .ltssm_enable = qcom_pcie_2_3_2_ltssm_enable,
1290 };
1291
1292 /* Qcom IP rev.: 2.4.0  Synopsys IP rev.: 4.20a */
1293 static const struct qcom_pcie_ops ops_2_4_0 = {
1294         .get_resources = qcom_pcie_get_resources_2_4_0,
1295         .init = qcom_pcie_init_2_4_0,
1296         .deinit = qcom_pcie_deinit_2_4_0,
1297         .ltssm_enable = qcom_pcie_2_3_2_ltssm_enable,
1298 };
1299
1300 /* Qcom IP rev.: 2.3.3  Synopsys IP rev.: 4.30a */
1301 static const struct qcom_pcie_ops ops_2_3_3 = {
1302         .get_resources = qcom_pcie_get_resources_2_3_3,
1303         .init = qcom_pcie_init_2_3_3,
1304         .deinit = qcom_pcie_deinit_2_3_3,
1305         .ltssm_enable = qcom_pcie_2_3_2_ltssm_enable,
1306 };
1307
1308 /* Qcom IP rev.: 2.7.0  Synopsys IP rev.: 4.30a */
1309 static const struct qcom_pcie_ops ops_2_7_0 = {
1310         .get_resources = qcom_pcie_get_resources_2_7_0,
1311         .init = qcom_pcie_init_2_7_0,
1312         .deinit = qcom_pcie_deinit_2_7_0,
1313         .ltssm_enable = qcom_pcie_2_3_2_ltssm_enable,
1314         .post_init = qcom_pcie_post_init_2_7_0,
1315         .post_deinit = qcom_pcie_post_deinit_2_7_0,
1316 };
1317
1318 static const struct dw_pcie_ops dw_pcie_ops = {
1319         .link_up = qcom_pcie_link_up,
1320 };
1321
1322 static int qcom_pcie_probe(struct platform_device *pdev)
1323 {
1324         struct device *dev = &pdev->dev;
1325         struct resource *res;
1326         struct pcie_port *pp;
1327         struct dw_pcie *pci;
1328         struct qcom_pcie *pcie;
1329         int ret;
1330
1331         pcie = devm_kzalloc(dev, sizeof(*pcie), GFP_KERNEL);
1332         if (!pcie)
1333                 return -ENOMEM;
1334
1335         pci = devm_kzalloc(dev, sizeof(*pci), GFP_KERNEL);
1336         if (!pci)
1337                 return -ENOMEM;
1338
1339         pm_runtime_enable(dev);
1340         ret = pm_runtime_get_sync(dev);
1341         if (ret < 0) {
1342                 pm_runtime_disable(dev);
1343                 return ret;
1344         }
1345
1346         pci->dev = dev;
1347         pci->ops = &dw_pcie_ops;
1348         pp = &pci->pp;
1349
1350         pcie->pci = pci;
1351
1352         pcie->ops = of_device_get_match_data(dev);
1353
1354         pcie->reset = devm_gpiod_get_optional(dev, "perst", GPIOD_OUT_HIGH);
1355         if (IS_ERR(pcie->reset)) {
1356                 ret = PTR_ERR(pcie->reset);
1357                 goto err_pm_runtime_put;
1358         }
1359
1360         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "parf");
1361         pcie->parf = devm_ioremap_resource(dev, res);
1362         if (IS_ERR(pcie->parf)) {
1363                 ret = PTR_ERR(pcie->parf);
1364                 goto err_pm_runtime_put;
1365         }
1366
1367         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dbi");
1368         pci->dbi_base = devm_pci_remap_cfg_resource(dev, res);
1369         if (IS_ERR(pci->dbi_base)) {
1370                 ret = PTR_ERR(pci->dbi_base);
1371                 goto err_pm_runtime_put;
1372         }
1373
1374         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "elbi");
1375         pcie->elbi = devm_ioremap_resource(dev, res);
1376         if (IS_ERR(pcie->elbi)) {
1377                 ret = PTR_ERR(pcie->elbi);
1378                 goto err_pm_runtime_put;
1379         }
1380
1381         pcie->phy = devm_phy_optional_get(dev, "pciephy");
1382         if (IS_ERR(pcie->phy)) {
1383                 ret = PTR_ERR(pcie->phy);
1384                 goto err_pm_runtime_put;
1385         }
1386
1387         ret = pcie->ops->get_resources(pcie);
1388         if (ret)
1389                 goto err_pm_runtime_put;
1390
1391         pp->ops = &qcom_pcie_dw_ops;
1392
1393         if (IS_ENABLED(CONFIG_PCI_MSI)) {
1394                 pp->msi_irq = platform_get_irq_byname(pdev, "msi");
1395                 if (pp->msi_irq < 0) {
1396                         ret = pp->msi_irq;
1397                         goto err_pm_runtime_put;
1398                 }
1399         }
1400
1401         ret = phy_init(pcie->phy);
1402         if (ret) {
1403                 pm_runtime_disable(&pdev->dev);
1404                 goto err_pm_runtime_put;
1405         }
1406
1407         platform_set_drvdata(pdev, pcie);
1408
1409         ret = dw_pcie_host_init(pp);
1410         if (ret) {
1411                 dev_err(dev, "cannot initialize host\n");
1412                 pm_runtime_disable(&pdev->dev);
1413                 goto err_pm_runtime_put;
1414         }
1415
1416         return 0;
1417
1418 err_pm_runtime_put:
1419         pm_runtime_put(dev);
1420         pm_runtime_disable(dev);
1421
1422         return ret;
1423 }
1424
1425 static const struct of_device_id qcom_pcie_match[] = {
1426         { .compatible = "qcom,pcie-apq8084", .data = &ops_1_0_0 },
1427         { .compatible = "qcom,pcie-ipq8064", .data = &ops_2_1_0 },
1428         { .compatible = "qcom,pcie-apq8064", .data = &ops_2_1_0 },
1429         { .compatible = "qcom,pcie-msm8996", .data = &ops_2_3_2 },
1430         { .compatible = "qcom,pcie-ipq8074", .data = &ops_2_3_3 },
1431         { .compatible = "qcom,pcie-ipq4019", .data = &ops_2_4_0 },
1432         { .compatible = "qcom,pcie-qcs404", .data = &ops_2_4_0 },
1433         { .compatible = "qcom,pcie-sdm845", .data = &ops_2_7_0 },
1434         { }
1435 };
1436
1437 static void qcom_fixup_class(struct pci_dev *dev)
1438 {
1439         dev->class = PCI_CLASS_BRIDGE_PCI << 8;
1440 }
1441 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_QCOM, 0x0101, qcom_fixup_class);
1442 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_QCOM, 0x0104, qcom_fixup_class);
1443 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_QCOM, 0x0106, qcom_fixup_class);
1444 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_QCOM, 0x0107, qcom_fixup_class);
1445 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_QCOM, 0x0302, qcom_fixup_class);
1446 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_QCOM, 0x1000, qcom_fixup_class);
1447 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_QCOM, 0x1001, qcom_fixup_class);
1448
1449 static struct platform_driver qcom_pcie_driver = {
1450         .probe = qcom_pcie_probe,
1451         .driver = {
1452                 .name = "qcom-pcie",
1453                 .suppress_bind_attrs = true,
1454                 .of_match_table = qcom_pcie_match,
1455         },
1456 };
1457 builtin_platform_driver(qcom_pcie_driver);