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