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/crc8.h>
  13 #include <linux/delay.h>
  14 #include <linux/gpio/consumer.h>
  15 #include <linux/interconnect.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/io.h>
  18 #include <linux/iopoll.h>
  19 #include <linux/kernel.h>
  20 #include <linux/init.h>
  21 #include <linux/of_device.h>
  22 #include <linux/of_gpio.h>
  23 #include <linux/pci.h>
  24 #include <linux/pm_runtime.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/phy/pcie.h>
  27 #include <linux/phy/phy.h>
  28 #include <linux/regulator/consumer.h>
  29 #include <linux/reset.h>
  30 #include <linux/slab.h>
  31 #include <linux/types.h>
  32
  33 #include "../../pci.h"
  34 #include "pcie-designware.h"
  35
  36 /* PARF registers */
  37 #define PARF_SYS_CTRL                           0x00
  38 #define PARF_PM_CTRL                            0x20
  39 #define PARF_PCS_DEEMPH                         0x34
  40 #define PARF_PCS_SWING                          0x38
  41 #define PARF_PHY_CTRL                           0x40
  42 #define PARF_PHY_REFCLK                         0x4c
  43 #define PARF_CONFIG_BITS                        0x50
  44 #define PARF_DBI_BASE_ADDR                      0x168
  45 #define PARF_SLV_ADDR_SPACE_SIZE_2_3_3          0x16c /* Register offset specific to IP ver 2.3.3 */
  46 #define PARF_MHI_CLOCK_RESET_CTRL               0x174
  47 #define PARF_AXI_MSTR_WR_ADDR_HALT              0x178
  48 #define PARF_AXI_MSTR_WR_ADDR_HALT_V2           0x1a8
  49 #define PARF_Q2A_FLUSH                          0x1ac
  50 #define PARF_LTSSM                              0x1b0
  51 #define PARF_SID_OFFSET                         0x234
  52 #define PARF_BDF_TRANSLATE_CFG                  0x24c
  53 #define PARF_SLV_ADDR_SPACE_SIZE                0x358
  54 #define PARF_DEVICE_TYPE                        0x1000
  55 #define PARF_BDF_TO_SID_TABLE_N                 0x2000
  56
  57 /* ELBI registers */
  58 #define ELBI_SYS_CTRL                           0x04
  59
  60 /* DBI registers */
  61 #define AXI_MSTR_RESP_COMP_CTRL0                0x818
  62 #define AXI_MSTR_RESP_COMP_CTRL1                0x81c
  63 #define MISC_CONTROL_1_REG                      0x8bc
  64
  65 /* PARF_SYS_CTRL register fields */
  66 #define MAC_PHY_POWERDOWN_IN_P2_D_MUX_EN        BIT(29)
  67 #define MST_WAKEUP_EN                           BIT(13)
  68 #define SLV_WAKEUP_EN                           BIT(12)
  69 #define MSTR_ACLK_CGC_DIS                       BIT(10)
  70 #define SLV_ACLK_CGC_DIS                        BIT(9)
  71 #define CORE_CLK_CGC_DIS                        BIT(6)
  72 #define AUX_PWR_DET                             BIT(4)
  73 #define L23_CLK_RMV_DIS                         BIT(2)
  74 #define L1_CLK_RMV_DIS                          BIT(1)
  75
  76 /* PARF_PM_CTRL register fields */
  77 #define REQ_NOT_ENTR_L1                         BIT(5)
  78
  79 /* PARF_PCS_DEEMPH register fields */
  80 #define PCS_DEEMPH_TX_DEEMPH_GEN1(x)            FIELD_PREP(GENMASK(21, 16), x)
  81 #define PCS_DEEMPH_TX_DEEMPH_GEN2_3_5DB(x)      FIELD_PREP(GENMASK(13, 8), x)
  82 #define PCS_DEEMPH_TX_DEEMPH_GEN2_6DB(x)        FIELD_PREP(GENMASK(5, 0), x)
  83
  84 /* PARF_PCS_SWING register fields */
  85 #define PCS_SWING_TX_SWING_FULL(x)              FIELD_PREP(GENMASK(14, 8), x)
  86 #define PCS_SWING_TX_SWING_LOW(x)               FIELD_PREP(GENMASK(6, 0), x)
  87
  88 /* PARF_PHY_CTRL register fields */
  89 #define PHY_CTRL_PHY_TX0_TERM_OFFSET_MASK       GENMASK(20, 16)
  90 #define PHY_CTRL_PHY_TX0_TERM_OFFSET(x)         FIELD_PREP(PHY_CTRL_PHY_TX0_TERM_OFFSET_MASK, x)
  91 #define PHY_TEST_PWR_DOWN                       BIT(0)
  92
  93 /* PARF_PHY_REFCLK register fields */
  94 #define PHY_REFCLK_SSP_EN                       BIT(16)
  95 #define PHY_REFCLK_USE_PAD                      BIT(12)
  96
  97 /* PARF_CONFIG_BITS register fields */
  98 #define PHY_RX0_EQ(x)                           FIELD_PREP(GENMASK(26, 24), x)
  99
 100 /* PARF_SLV_ADDR_SPACE_SIZE register value */
 101 #define SLV_ADDR_SPACE_SZ                       0x10000000
 102
 103 /* PARF_MHI_CLOCK_RESET_CTRL register fields */
 104 #define AHB_CLK_EN                              BIT(0)
 105 #define MSTR_AXI_CLK_EN                         BIT(1)
 106 #define BYPASS                                  BIT(4)
 107
 108 /* PARF_AXI_MSTR_WR_ADDR_HALT register fields */
 109 #define EN                                      BIT(31)
 110
 111 /* PARF_LTSSM register fields */
 112 #define LTSSM_EN                                BIT(8)
 113
 114 /* PARF_DEVICE_TYPE register fields */
 115 #define DEVICE_TYPE_RC                          0x4
 116
 117 /* ELBI_SYS_CTRL register fields */
 118 #define ELBI_SYS_CTRL_LT_ENABLE                 BIT(0)
 119
 120 /* AXI_MSTR_RESP_COMP_CTRL0 register fields */
 121 #define CFG_REMOTE_RD_REQ_BRIDGE_SIZE_2K        0x4
 122 #define CFG_REMOTE_RD_REQ_BRIDGE_SIZE_4K        0x5
 123
 124 /* AXI_MSTR_RESP_COMP_CTRL1 register fields */
 125 #define CFG_BRIDGE_SB_INIT                      BIT(0)
 126
 127 /* MISC_CONTROL_1_REG register fields */
 128 #define DBI_RO_WR_EN                            1
 129
 130 /* PCI_EXP_SLTCAP register fields */
 131 #define PCIE_CAP_SLOT_POWER_LIMIT_VAL           FIELD_PREP(PCI_EXP_SLTCAP_SPLV, 250)
 132 #define PCIE_CAP_SLOT_POWER_LIMIT_SCALE         FIELD_PREP(PCI_EXP_SLTCAP_SPLS, 1)
 133 #define PCIE_CAP_SLOT_VAL                       (PCI_EXP_SLTCAP_ABP | \
 134                                                 PCI_EXP_SLTCAP_PCP | \
 135                                                 PCI_EXP_SLTCAP_MRLSP | \
 136                                                 PCI_EXP_SLTCAP_AIP | \
 137                                                 PCI_EXP_SLTCAP_PIP | \
 138                                                 PCI_EXP_SLTCAP_HPS | \
 139                                                 PCI_EXP_SLTCAP_HPC | \
 140                                                 PCI_EXP_SLTCAP_EIP | \
 141                                                 PCIE_CAP_SLOT_POWER_LIMIT_VAL | \
 142                                                 PCIE_CAP_SLOT_POWER_LIMIT_SCALE)
 143
 144 #define PERST_DELAY_US                          1000
 145
 146 #define QCOM_PCIE_CRC8_POLYNOMIAL               (BIT(2) | BIT(1) | BIT(0))
 147
 148 #define QCOM_PCIE_1_0_0_MAX_CLOCKS              4
 149 struct qcom_pcie_resources_1_0_0 {
 150         struct clk_bulk_data clks[QCOM_PCIE_1_0_0_MAX_CLOCKS];
 151         struct reset_control *core;
 152         struct regulator *vdda;
 153 };
 154
 155 #define QCOM_PCIE_2_1_0_MAX_CLOCKS              5
 156 #define QCOM_PCIE_2_1_0_MAX_RESETS              6
 157 #define QCOM_PCIE_2_1_0_MAX_SUPPLY              3
 158 struct qcom_pcie_resources_2_1_0 {
 159         struct clk_bulk_data clks[QCOM_PCIE_2_1_0_MAX_CLOCKS];
 160         struct reset_control_bulk_data resets[QCOM_PCIE_2_1_0_MAX_RESETS];
 161         int num_resets;
 162         struct regulator_bulk_data supplies[QCOM_PCIE_2_1_0_MAX_SUPPLY];
 163 };
 164
 165 #define QCOM_PCIE_2_3_2_MAX_SUPPLY      2
 166 struct qcom_pcie_resources_2_3_2 {
 167         struct clk *aux_clk;
 168         struct clk *master_clk;
 169         struct clk *slave_clk;
 170         struct clk *cfg_clk;
 171         struct regulator_bulk_data supplies[QCOM_PCIE_2_3_2_MAX_SUPPLY];
 172 };
 173
 174 #define QCOM_PCIE_2_4_0_MAX_CLOCKS      4
 175 struct qcom_pcie_resources_2_4_0 {
 176         struct clk_bulk_data clks[QCOM_PCIE_2_4_0_MAX_CLOCKS];
 177         int num_clks;
 178         struct reset_control *axi_m_reset;
 179         struct reset_control *axi_s_reset;
 180         struct reset_control *pipe_reset;
 181         struct reset_control *axi_m_vmid_reset;
 182         struct reset_control *axi_s_xpu_reset;
 183         struct reset_control *parf_reset;
 184         struct reset_control *phy_reset;
 185         struct reset_control *axi_m_sticky_reset;
 186         struct reset_control *pipe_sticky_reset;
 187         struct reset_control *pwr_reset;
 188         struct reset_control *ahb_reset;
 189         struct reset_control *phy_ahb_reset;
 190 };
 191
 192 struct qcom_pcie_resources_2_3_3 {
 193         struct clk *iface;
 194         struct clk *axi_m_clk;
 195         struct clk *axi_s_clk;
 196         struct clk *ahb_clk;
 197         struct clk *aux_clk;
 198         struct reset_control *rst[7];
 199 };
 200
 201 /* 6 clocks typically, 7 for sm8250 */
 202 struct qcom_pcie_resources_2_7_0 {
 203         struct clk_bulk_data clks[12];
 204         int num_clks;
 205         struct regulator_bulk_data supplies[2];
 206         struct reset_control *pci_reset;
 207 };
 208
 209 struct qcom_pcie_resources_2_9_0 {
 210         struct clk_bulk_data clks[5];
 211         struct reset_control *rst;
 212 };
 213
 214 union qcom_pcie_resources {
 215         struct qcom_pcie_resources_1_0_0 v1_0_0;
 216         struct qcom_pcie_resources_2_1_0 v2_1_0;
 217         struct qcom_pcie_resources_2_3_2 v2_3_2;
 218         struct qcom_pcie_resources_2_3_3 v2_3_3;
 219         struct qcom_pcie_resources_2_4_0 v2_4_0;
 220         struct qcom_pcie_resources_2_7_0 v2_7_0;
 221         struct qcom_pcie_resources_2_9_0 v2_9_0;
 222 };
 223
 224 struct qcom_pcie;
 225
 226 struct qcom_pcie_ops {
 227         int (*get_resources)(struct qcom_pcie *pcie);
 228         int (*init)(struct qcom_pcie *pcie);
 229         int (*post_init)(struct qcom_pcie *pcie);
 230         void (*deinit)(struct qcom_pcie *pcie);
 231         void (*ltssm_enable)(struct qcom_pcie *pcie);
 232         int (*config_sid)(struct qcom_pcie *pcie);
 233 };
 234
 235 struct qcom_pcie_cfg {
 236         const struct qcom_pcie_ops *ops;
 237 };
 238
 239 struct qcom_pcie {
 240         struct dw_pcie *pci;
 241         void __iomem *parf;                     /* DT parf */
 242         void __iomem *elbi;                     /* DT elbi */
 243         union qcom_pcie_resources res;
 244         struct phy *phy;
 245         struct gpio_desc *reset;
 246         struct icc_path *icc_mem;
 247         const struct qcom_pcie_cfg *cfg;
 248 };
 249
 250 #define to_qcom_pcie(x)         dev_get_drvdata((x)->dev)
 251
 252 static void qcom_ep_reset_assert(struct qcom_pcie *pcie)
 253 {
 254         gpiod_set_value_cansleep(pcie->reset, 1);
 255         usleep_range(PERST_DELAY_US, PERST_DELAY_US + 500);
 256 }
 257
 258 static void qcom_ep_reset_deassert(struct qcom_pcie *pcie)
 259 {
 260         /* Ensure that PERST has been asserted for at least 100 ms */
 261         msleep(100);
 262         gpiod_set_value_cansleep(pcie->reset, 0);
 263         usleep_range(PERST_DELAY_US, PERST_DELAY_US + 500);
 264 }
 265
 266 static int qcom_pcie_start_link(struct dw_pcie *pci)
 267 {
 268         struct qcom_pcie *pcie = to_qcom_pcie(pci);
 269
 270         /* Enable Link Training state machine */
 271         if (pcie->cfg->ops->ltssm_enable)
 272                 pcie->cfg->ops->ltssm_enable(pcie);
 273
 274         return 0;
 275 }
 276
 277 static void qcom_pcie_2_1_0_ltssm_enable(struct qcom_pcie *pcie)
 278 {
 279         u32 val;
 280
 281         /* enable link training */
 282         val = readl(pcie->elbi + ELBI_SYS_CTRL);
 283         val |= ELBI_SYS_CTRL_LT_ENABLE;
 284         writel(val, pcie->elbi + ELBI_SYS_CTRL);
 285 }
 286
 287 static int qcom_pcie_get_resources_2_1_0(struct qcom_pcie *pcie)
 288 {
 289         struct qcom_pcie_resources_2_1_0 *res = &pcie->res.v2_1_0;
 290         struct dw_pcie *pci = pcie->pci;
 291         struct device *dev = pci->dev;
 292         bool is_apq = of_device_is_compatible(dev->of_node, "qcom,pcie-apq8064");
 293         int ret;
 294
 295         res->supplies[0].supply = "vdda";
 296         res->supplies[1].supply = "vdda_phy";
 297         res->supplies[2].supply = "vdda_refclk";
 298         ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(res->supplies),
 299                                       res->supplies);
 300         if (ret)
 301                 return ret;
 302
 303         res->clks[0].id = "iface";
 304         res->clks[1].id = "core";
 305         res->clks[2].id = "phy";
 306         res->clks[3].id = "aux";
 307         res->clks[4].id = "ref";
 308
 309         /* iface, core, phy are required */
 310         ret = devm_clk_bulk_get(dev, 3, res->clks);
 311         if (ret < 0)
 312                 return ret;
 313
 314         /* aux, ref are optional */
 315         ret = devm_clk_bulk_get_optional(dev, 2, res->clks + 3);
 316         if (ret < 0)
 317                 return ret;
 318
 319         res->resets[0].id = "pci";
 320         res->resets[1].id = "axi";
 321         res->resets[2].id = "ahb";
 322         res->resets[3].id = "por";
 323         res->resets[4].id = "phy";
 324         res->resets[5].id = "ext";
 325
 326         /* ext is optional on APQ8016 */
 327         res->num_resets = is_apq ? 5 : 6;
 328         ret = devm_reset_control_bulk_get_exclusive(dev, res->num_resets, res->resets);
 329         if (ret < 0)
 330                 return ret;
 331
 332         return 0;
 333 }
 334
 335 static void qcom_pcie_deinit_2_1_0(struct qcom_pcie *pcie)
 336 {
 337         struct qcom_pcie_resources_2_1_0 *res = &pcie->res.v2_1_0;
 338
 339         clk_bulk_disable_unprepare(ARRAY_SIZE(res->clks), res->clks);
 340         reset_control_bulk_assert(res->num_resets, res->resets);
 341
 342         writel(1, pcie->parf + PARF_PHY_CTRL);
 343
 344         regulator_bulk_disable(ARRAY_SIZE(res->supplies), res->supplies);
 345 }
 346
 347 static int qcom_pcie_init_2_1_0(struct qcom_pcie *pcie)
 348 {
 349         struct qcom_pcie_resources_2_1_0 *res = &pcie->res.v2_1_0;
 350         struct dw_pcie *pci = pcie->pci;
 351         struct device *dev = pci->dev;
 352         int ret;
 353
 354         /* reset the PCIe interface as uboot can leave it undefined state */
 355         ret = reset_control_bulk_assert(res->num_resets, res->resets);
 356         if (ret < 0) {
 357                 dev_err(dev, "cannot assert resets\n");
 358                 return ret;
 359         }
 360
 361         ret = regulator_bulk_enable(ARRAY_SIZE(res->supplies), res->supplies);
 362         if (ret < 0) {
 363                 dev_err(dev, "cannot enable regulators\n");
 364                 return ret;
 365         }
 366
 367         ret = reset_control_bulk_deassert(res->num_resets, res->resets);
 368         if (ret < 0) {
 369                 dev_err(dev, "cannot deassert resets\n");
 370                 regulator_bulk_disable(ARRAY_SIZE(res->supplies), res->supplies);
 371                 return ret;
 372         }
 373
 374         return 0;
 375 }
 376
 377 static int qcom_pcie_post_init_2_1_0(struct qcom_pcie *pcie)
 378 {
 379         struct qcom_pcie_resources_2_1_0 *res = &pcie->res.v2_1_0;
 380         struct dw_pcie *pci = pcie->pci;
 381         struct device *dev = pci->dev;
 382         struct device_node *node = dev->of_node;
 383         u32 val;
 384         int ret;
 385
 386         /* enable PCIe clocks and resets */
 387         val = readl(pcie->parf + PARF_PHY_CTRL);
 388         val &= ~PHY_TEST_PWR_DOWN;
 389         writel(val, pcie->parf + PARF_PHY_CTRL);
 390
 391         ret = clk_bulk_prepare_enable(ARRAY_SIZE(res->clks), res->clks);
 392         if (ret)
 393                 return ret;
 394
 395         if (of_device_is_compatible(node, "qcom,pcie-ipq8064") ||
 396             of_device_is_compatible(node, "qcom,pcie-ipq8064-v2")) {
 397                 writel(PCS_DEEMPH_TX_DEEMPH_GEN1(24) |
 398                                PCS_DEEMPH_TX_DEEMPH_GEN2_3_5DB(24) |
 399                                PCS_DEEMPH_TX_DEEMPH_GEN2_6DB(34),
 400                        pcie->parf + PARF_PCS_DEEMPH);
 401                 writel(PCS_SWING_TX_SWING_FULL(120) |
 402                                PCS_SWING_TX_SWING_LOW(120),
 403                        pcie->parf + PARF_PCS_SWING);
 404                 writel(PHY_RX0_EQ(4), pcie->parf + PARF_CONFIG_BITS);
 405         }
 406
 407         if (of_device_is_compatible(node, "qcom,pcie-ipq8064")) {
 408                 /* set TX termination offset */
 409                 val = readl(pcie->parf + PARF_PHY_CTRL);
 410                 val &= ~PHY_CTRL_PHY_TX0_TERM_OFFSET_MASK;
 411                 val |= PHY_CTRL_PHY_TX0_TERM_OFFSET(7);
 412                 writel(val, pcie->parf + PARF_PHY_CTRL);
 413         }
 414
 415         /* enable external reference clock */
 416         val = readl(pcie->parf + PARF_PHY_REFCLK);
 417         /* USE_PAD is required only for ipq806x */
 418         if (!of_device_is_compatible(node, "qcom,pcie-apq8064"))
 419                 val &= ~PHY_REFCLK_USE_PAD;
 420         val |= PHY_REFCLK_SSP_EN;
 421         writel(val, pcie->parf + PARF_PHY_REFCLK);
 422
 423         /* wait for clock acquisition */
 424         usleep_range(1000, 1500);
 425
 426         /* Set the Max TLP size to 2K, instead of using default of 4K */
 427         writel(CFG_REMOTE_RD_REQ_BRIDGE_SIZE_2K,
 428                pci->dbi_base + AXI_MSTR_RESP_COMP_CTRL0);
 429         writel(CFG_BRIDGE_SB_INIT,
 430                pci->dbi_base + AXI_MSTR_RESP_COMP_CTRL1);
 431
 432         return 0;
 433 }
 434
 435 static int qcom_pcie_get_resources_1_0_0(struct qcom_pcie *pcie)
 436 {
 437         struct qcom_pcie_resources_1_0_0 *res = &pcie->res.v1_0_0;
 438         struct dw_pcie *pci = pcie->pci;
 439         struct device *dev = pci->dev;
 440         int ret;
 441
 442         res->vdda = devm_regulator_get(dev, "vdda");
 443         if (IS_ERR(res->vdda))
 444                 return PTR_ERR(res->vdda);
 445
 446         res->clks[0].id = "iface";
 447         res->clks[1].id = "aux";
 448         res->clks[2].id = "master_bus";
 449         res->clks[3].id = "slave_bus";
 450
 451         ret = devm_clk_bulk_get(dev, ARRAY_SIZE(res->clks), res->clks);
 452         if (ret < 0)
 453                 return ret;
 454
 455         res->core = devm_reset_control_get_exclusive(dev, "core");
 456         return PTR_ERR_OR_ZERO(res->core);
 457 }
 458
 459 static void qcom_pcie_deinit_1_0_0(struct qcom_pcie *pcie)
 460 {
 461         struct qcom_pcie_resources_1_0_0 *res = &pcie->res.v1_0_0;
 462
 463         reset_control_assert(res->core);
 464         clk_bulk_disable_unprepare(ARRAY_SIZE(res->clks), res->clks);
 465         regulator_disable(res->vdda);
 466 }
 467
 468 static int qcom_pcie_init_1_0_0(struct qcom_pcie *pcie)
 469 {
 470         struct qcom_pcie_resources_1_0_0 *res = &pcie->res.v1_0_0;
 471         struct dw_pcie *pci = pcie->pci;
 472         struct device *dev = pci->dev;
 473         int ret;
 474
 475         ret = reset_control_deassert(res->core);
 476         if (ret) {
 477                 dev_err(dev, "cannot deassert core reset\n");
 478                 return ret;
 479         }
 480
 481         ret = clk_bulk_prepare_enable(ARRAY_SIZE(res->clks), res->clks);
 482         if (ret) {
 483                 dev_err(dev, "cannot prepare/enable clocks\n");
 484                 goto err_assert_reset;
 485         }
 486
 487         ret = regulator_enable(res->vdda);
 488         if (ret) {
 489                 dev_err(dev, "cannot enable vdda regulator\n");
 490                 goto err_disable_clks;
 491         }
 492
 493         return 0;
 494
 495 err_disable_clks:
 496         clk_bulk_disable_unprepare(ARRAY_SIZE(res->clks), res->clks);
 497 err_assert_reset:
 498         reset_control_assert(res->core);
 499
 500         return ret;
 501 }
 502
 503 static int qcom_pcie_post_init_1_0_0(struct qcom_pcie *pcie)
 504 {
 505         /* change DBI base address */
 506         writel(0, pcie->parf + PARF_DBI_BASE_ADDR);
 507
 508         if (IS_ENABLED(CONFIG_PCI_MSI)) {
 509                 u32 val = readl(pcie->parf + PARF_AXI_MSTR_WR_ADDR_HALT);
 510
 511                 val |= EN;
 512                 writel(val, pcie->parf + PARF_AXI_MSTR_WR_ADDR_HALT);
 513         }
 514
 515         return 0;
 516 }
 517
 518 static void qcom_pcie_2_3_2_ltssm_enable(struct qcom_pcie *pcie)
 519 {
 520         u32 val;
 521
 522         /* enable link training */
 523         val = readl(pcie->parf + PARF_LTSSM);
 524         val |= LTSSM_EN;
 525         writel(val, pcie->parf + PARF_LTSSM);
 526 }
 527
 528 static int qcom_pcie_get_resources_2_3_2(struct qcom_pcie *pcie)
 529 {
 530         struct qcom_pcie_resources_2_3_2 *res = &pcie->res.v2_3_2;
 531         struct dw_pcie *pci = pcie->pci;
 532         struct device *dev = pci->dev;
 533         int ret;
 534
 535         res->supplies[0].supply = "vdda";
 536         res->supplies[1].supply = "vddpe-3v3";
 537         ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(res->supplies),
 538                                       res->supplies);
 539         if (ret)
 540                 return ret;
 541
 542         res->aux_clk = devm_clk_get(dev, "aux");
 543         if (IS_ERR(res->aux_clk))
 544                 return PTR_ERR(res->aux_clk);
 545
 546         res->cfg_clk = devm_clk_get(dev, "cfg");
 547         if (IS_ERR(res->cfg_clk))
 548                 return PTR_ERR(res->cfg_clk);
 549
 550         res->master_clk = devm_clk_get(dev, "bus_master");
 551         if (IS_ERR(res->master_clk))
 552                 return PTR_ERR(res->master_clk);
 553
 554         res->slave_clk = devm_clk_get(dev, "bus_slave");
 555         if (IS_ERR(res->slave_clk))
 556                 return PTR_ERR(res->slave_clk);
 557
 558         return 0;
 559 }
 560
 561 static void qcom_pcie_deinit_2_3_2(struct qcom_pcie *pcie)
 562 {
 563         struct qcom_pcie_resources_2_3_2 *res = &pcie->res.v2_3_2;
 564
 565         clk_disable_unprepare(res->slave_clk);
 566         clk_disable_unprepare(res->master_clk);
 567         clk_disable_unprepare(res->cfg_clk);
 568         clk_disable_unprepare(res->aux_clk);
 569
 570         regulator_bulk_disable(ARRAY_SIZE(res->supplies), res->supplies);
 571 }
 572
 573 static int qcom_pcie_init_2_3_2(struct qcom_pcie *pcie)
 574 {
 575         struct qcom_pcie_resources_2_3_2 *res = &pcie->res.v2_3_2;
 576         struct dw_pcie *pci = pcie->pci;
 577         struct device *dev = pci->dev;
 578         int ret;
 579
 580         ret = regulator_bulk_enable(ARRAY_SIZE(res->supplies), res->supplies);
 581         if (ret < 0) {
 582                 dev_err(dev, "cannot enable regulators\n");
 583                 return ret;
 584         }
 585
 586         ret = clk_prepare_enable(res->aux_clk);
 587         if (ret) {
 588                 dev_err(dev, "cannot prepare/enable aux clock\n");
 589                 goto err_aux_clk;
 590         }
 591
 592         ret = clk_prepare_enable(res->cfg_clk);
 593         if (ret) {
 594                 dev_err(dev, "cannot prepare/enable cfg clock\n");
 595                 goto err_cfg_clk;
 596         }
 597
 598         ret = clk_prepare_enable(res->master_clk);
 599         if (ret) {
 600                 dev_err(dev, "cannot prepare/enable master clock\n");
 601                 goto err_master_clk;
 602         }
 603
 604         ret = clk_prepare_enable(res->slave_clk);
 605         if (ret) {
 606                 dev_err(dev, "cannot prepare/enable slave clock\n");
 607                 goto err_slave_clk;
 608         }
 609
 610         return 0;
 611
 612 err_slave_clk:
 613         clk_disable_unprepare(res->master_clk);
 614 err_master_clk:
 615         clk_disable_unprepare(res->cfg_clk);
 616 err_cfg_clk:
 617         clk_disable_unprepare(res->aux_clk);
 618
 619 err_aux_clk:
 620         regulator_bulk_disable(ARRAY_SIZE(res->supplies), res->supplies);
 621
 622         return ret;
 623 }
 624
 625 static int qcom_pcie_post_init_2_3_2(struct qcom_pcie *pcie)
 626 {
 627         u32 val;
 628
 629         /* enable PCIe clocks and resets */
 630         val = readl(pcie->parf + PARF_PHY_CTRL);
 631         val &= ~PHY_TEST_PWR_DOWN;
 632         writel(val, pcie->parf + PARF_PHY_CTRL);
 633
 634         /* change DBI base address */
 635         writel(0, pcie->parf + PARF_DBI_BASE_ADDR);
 636
 637         /* MAC PHY_POWERDOWN MUX DISABLE  */
 638         val = readl(pcie->parf + PARF_SYS_CTRL);
 639         val &= ~MAC_PHY_POWERDOWN_IN_P2_D_MUX_EN;
 640         writel(val, pcie->parf + PARF_SYS_CTRL);
 641
 642         val = readl(pcie->parf + PARF_MHI_CLOCK_RESET_CTRL);
 643         val |= BYPASS;
 644         writel(val, pcie->parf + PARF_MHI_CLOCK_RESET_CTRL);
 645
 646         val = readl(pcie->parf + PARF_AXI_MSTR_WR_ADDR_HALT_V2);
 647         val |= EN;
 648         writel(val, pcie->parf + PARF_AXI_MSTR_WR_ADDR_HALT_V2);
 649
 650         return 0;
 651 }
 652
 653 static int qcom_pcie_get_resources_2_4_0(struct qcom_pcie *pcie)
 654 {
 655         struct qcom_pcie_resources_2_4_0 *res = &pcie->res.v2_4_0;
 656         struct dw_pcie *pci = pcie->pci;
 657         struct device *dev = pci->dev;
 658         bool is_ipq = of_device_is_compatible(dev->of_node, "qcom,pcie-ipq4019");
 659         int ret;
 660
 661         res->clks[0].id = "aux";
 662         res->clks[1].id = "master_bus";
 663         res->clks[2].id = "slave_bus";
 664         res->clks[3].id = "iface";
 665
 666         /* qcom,pcie-ipq4019 is defined without "iface" */
 667         res->num_clks = is_ipq ? 3 : 4;
 668
 669         ret = devm_clk_bulk_get(dev, res->num_clks, res->clks);
 670         if (ret < 0)
 671                 return ret;
 672
 673         res->axi_m_reset = devm_reset_control_get_exclusive(dev, "axi_m");
 674         if (IS_ERR(res->axi_m_reset))
 675                 return PTR_ERR(res->axi_m_reset);
 676
 677         res->axi_s_reset = devm_reset_control_get_exclusive(dev, "axi_s");
 678         if (IS_ERR(res->axi_s_reset))
 679                 return PTR_ERR(res->axi_s_reset);
 680
 681         if (is_ipq) {
 682                 /*
 683                  * These resources relates to the PHY or are secure clocks, but
 684                  * are controlled here for IPQ4019
 685                  */
 686                 res->pipe_reset = devm_reset_control_get_exclusive(dev, "pipe");
 687                 if (IS_ERR(res->pipe_reset))
 688                         return PTR_ERR(res->pipe_reset);
 689
 690                 res->axi_m_vmid_reset = devm_reset_control_get_exclusive(dev,
 691                                                                          "axi_m_vmid");
 692                 if (IS_ERR(res->axi_m_vmid_reset))
 693                         return PTR_ERR(res->axi_m_vmid_reset);
 694
 695                 res->axi_s_xpu_reset = devm_reset_control_get_exclusive(dev,
 696                                                                         "axi_s_xpu");
 697                 if (IS_ERR(res->axi_s_xpu_reset))
 698                         return PTR_ERR(res->axi_s_xpu_reset);
 699
 700                 res->parf_reset = devm_reset_control_get_exclusive(dev, "parf");
 701                 if (IS_ERR(res->parf_reset))
 702                         return PTR_ERR(res->parf_reset);
 703
 704                 res->phy_reset = devm_reset_control_get_exclusive(dev, "phy");
 705                 if (IS_ERR(res->phy_reset))
 706                         return PTR_ERR(res->phy_reset);
 707         }
 708
 709         res->axi_m_sticky_reset = devm_reset_control_get_exclusive(dev,
 710                                                                    "axi_m_sticky");
 711         if (IS_ERR(res->axi_m_sticky_reset))
 712                 return PTR_ERR(res->axi_m_sticky_reset);
 713
 714         res->pipe_sticky_reset = devm_reset_control_get_exclusive(dev,
 715                                                                   "pipe_sticky");
 716         if (IS_ERR(res->pipe_sticky_reset))
 717                 return PTR_ERR(res->pipe_sticky_reset);
 718
 719         res->pwr_reset = devm_reset_control_get_exclusive(dev, "pwr");
 720         if (IS_ERR(res->pwr_reset))
 721                 return PTR_ERR(res->pwr_reset);
 722
 723         res->ahb_reset = devm_reset_control_get_exclusive(dev, "ahb");
 724         if (IS_ERR(res->ahb_reset))
 725                 return PTR_ERR(res->ahb_reset);
 726
 727         if (is_ipq) {
 728                 res->phy_ahb_reset = devm_reset_control_get_exclusive(dev, "phy_ahb");
 729                 if (IS_ERR(res->phy_ahb_reset))
 730                         return PTR_ERR(res->phy_ahb_reset);
 731         }
 732
 733         return 0;
 734 }
 735
 736 static void qcom_pcie_deinit_2_4_0(struct qcom_pcie *pcie)
 737 {
 738         struct qcom_pcie_resources_2_4_0 *res = &pcie->res.v2_4_0;
 739
 740         reset_control_assert(res->axi_m_reset);
 741         reset_control_assert(res->axi_s_reset);
 742         reset_control_assert(res->pipe_reset);
 743         reset_control_assert(res->pipe_sticky_reset);
 744         reset_control_assert(res->phy_reset);
 745         reset_control_assert(res->phy_ahb_reset);
 746         reset_control_assert(res->axi_m_sticky_reset);
 747         reset_control_assert(res->pwr_reset);
 748         reset_control_assert(res->ahb_reset);
 749         clk_bulk_disable_unprepare(res->num_clks, res->clks);
 750 }
 751
 752 static int qcom_pcie_init_2_4_0(struct qcom_pcie *pcie)
 753 {
 754         struct qcom_pcie_resources_2_4_0 *res = &pcie->res.v2_4_0;
 755         struct dw_pcie *pci = pcie->pci;
 756         struct device *dev = pci->dev;
 757         int ret;
 758
 759         ret = reset_control_assert(res->axi_m_reset);
 760         if (ret) {
 761                 dev_err(dev, "cannot assert axi master reset\n");
 762                 return ret;
 763         }
 764
 765         ret = reset_control_assert(res->axi_s_reset);
 766         if (ret) {
 767                 dev_err(dev, "cannot assert axi slave reset\n");
 768                 return ret;
 769         }
 770
 771         usleep_range(10000, 12000);
 772
 773         ret = reset_control_assert(res->pipe_reset);
 774         if (ret) {
 775                 dev_err(dev, "cannot assert pipe reset\n");
 776                 return ret;
 777         }
 778
 779         ret = reset_control_assert(res->pipe_sticky_reset);
 780         if (ret) {
 781                 dev_err(dev, "cannot assert pipe sticky reset\n");
 782                 return ret;
 783         }
 784
 785         ret = reset_control_assert(res->phy_reset);
 786         if (ret) {
 787                 dev_err(dev, "cannot assert phy reset\n");
 788                 return ret;
 789         }
 790
 791         ret = reset_control_assert(res->phy_ahb_reset);
 792         if (ret) {
 793                 dev_err(dev, "cannot assert phy ahb reset\n");
 794                 return ret;
 795         }
 796
 797         usleep_range(10000, 12000);
 798
 799         ret = reset_control_assert(res->axi_m_sticky_reset);
 800         if (ret) {
 801                 dev_err(dev, "cannot assert axi master sticky reset\n");
 802                 return ret;
 803         }
 804
 805         ret = reset_control_assert(res->pwr_reset);
 806         if (ret) {
 807                 dev_err(dev, "cannot assert power reset\n");
 808                 return ret;
 809         }
 810
 811         ret = reset_control_assert(res->ahb_reset);
 812         if (ret) {
 813                 dev_err(dev, "cannot assert ahb reset\n");
 814                 return ret;
 815         }
 816
 817         usleep_range(10000, 12000);
 818
 819         ret = reset_control_deassert(res->phy_ahb_reset);
 820         if (ret) {
 821                 dev_err(dev, "cannot deassert phy ahb reset\n");
 822                 return ret;
 823         }
 824
 825         ret = reset_control_deassert(res->phy_reset);
 826         if (ret) {
 827                 dev_err(dev, "cannot deassert phy reset\n");
 828                 goto err_rst_phy;
 829         }
 830
 831         ret = reset_control_deassert(res->pipe_reset);
 832         if (ret) {
 833                 dev_err(dev, "cannot deassert pipe reset\n");
 834                 goto err_rst_pipe;
 835         }
 836
 837         ret = reset_control_deassert(res->pipe_sticky_reset);
 838         if (ret) {
 839                 dev_err(dev, "cannot deassert pipe sticky reset\n");
 840                 goto err_rst_pipe_sticky;
 841         }
 842
 843         usleep_range(10000, 12000);
 844
 845         ret = reset_control_deassert(res->axi_m_reset);
 846         if (ret) {
 847                 dev_err(dev, "cannot deassert axi master reset\n");
 848                 goto err_rst_axi_m;
 849         }
 850
 851         ret = reset_control_deassert(res->axi_m_sticky_reset);
 852         if (ret) {
 853                 dev_err(dev, "cannot deassert axi master sticky reset\n");
 854                 goto err_rst_axi_m_sticky;
 855         }
 856
 857         ret = reset_control_deassert(res->axi_s_reset);
 858         if (ret) {
 859                 dev_err(dev, "cannot deassert axi slave reset\n");
 860                 goto err_rst_axi_s;
 861         }
 862
 863         ret = reset_control_deassert(res->pwr_reset);
 864         if (ret) {
 865                 dev_err(dev, "cannot deassert power reset\n");
 866                 goto err_rst_pwr;
 867         }
 868
 869         ret = reset_control_deassert(res->ahb_reset);
 870         if (ret) {
 871                 dev_err(dev, "cannot deassert ahb reset\n");
 872                 goto err_rst_ahb;
 873         }
 874
 875         usleep_range(10000, 12000);
 876
 877         ret = clk_bulk_prepare_enable(res->num_clks, res->clks);
 878         if (ret)
 879                 goto err_clks;
 880
 881         return 0;
 882
 883 err_clks:
 884         reset_control_assert(res->ahb_reset);
 885 err_rst_ahb:
 886         reset_control_assert(res->pwr_reset);
 887 err_rst_pwr:
 888         reset_control_assert(res->axi_s_reset);
 889 err_rst_axi_s:
 890         reset_control_assert(res->axi_m_sticky_reset);
 891 err_rst_axi_m_sticky:
 892         reset_control_assert(res->axi_m_reset);
 893 err_rst_axi_m:
 894         reset_control_assert(res->pipe_sticky_reset);
 895 err_rst_pipe_sticky:
 896         reset_control_assert(res->pipe_reset);
 897 err_rst_pipe:
 898         reset_control_assert(res->phy_reset);
 899 err_rst_phy:
 900         reset_control_assert(res->phy_ahb_reset);
 901         return ret;
 902 }
 903
 904 static int qcom_pcie_post_init_2_4_0(struct qcom_pcie *pcie)
 905 {
 906         u32 val;
 907
 908         /* enable PCIe clocks and resets */
 909         val = readl(pcie->parf + PARF_PHY_CTRL);
 910         val &= ~PHY_TEST_PWR_DOWN;
 911         writel(val, pcie->parf + PARF_PHY_CTRL);
 912
 913         /* change DBI base address */
 914         writel(0, pcie->parf + PARF_DBI_BASE_ADDR);
 915
 916         /* MAC PHY_POWERDOWN MUX DISABLE  */
 917         val = readl(pcie->parf + PARF_SYS_CTRL);
 918         val &= ~MAC_PHY_POWERDOWN_IN_P2_D_MUX_EN;
 919         writel(val, pcie->parf + PARF_SYS_CTRL);
 920
 921         val = readl(pcie->parf + PARF_MHI_CLOCK_RESET_CTRL);
 922         val |= BYPASS;
 923         writel(val, pcie->parf + PARF_MHI_CLOCK_RESET_CTRL);
 924
 925         val = readl(pcie->parf + PARF_AXI_MSTR_WR_ADDR_HALT_V2);
 926         val |= EN;
 927         writel(val, pcie->parf + PARF_AXI_MSTR_WR_ADDR_HALT_V2);
 928
 929         return 0;
 930 }
 931
 932 static int qcom_pcie_get_resources_2_3_3(struct qcom_pcie *pcie)
 933 {
 934         struct qcom_pcie_resources_2_3_3 *res = &pcie->res.v2_3_3;
 935         struct dw_pcie *pci = pcie->pci;
 936         struct device *dev = pci->dev;
 937         int i;
 938         const char *rst_names[] = { "axi_m", "axi_s", "pipe",
 939                                     "axi_m_sticky", "sticky",
 940                                     "ahb", "sleep", };
 941
 942         res->iface = devm_clk_get(dev, "iface");
 943         if (IS_ERR(res->iface))
 944                 return PTR_ERR(res->iface);
 945
 946         res->axi_m_clk = devm_clk_get(dev, "axi_m");
 947         if (IS_ERR(res->axi_m_clk))
 948                 return PTR_ERR(res->axi_m_clk);
 949
 950         res->axi_s_clk = devm_clk_get(dev, "axi_s");
 951         if (IS_ERR(res->axi_s_clk))
 952                 return PTR_ERR(res->axi_s_clk);
 953
 954         res->ahb_clk = devm_clk_get(dev, "ahb");
 955         if (IS_ERR(res->ahb_clk))
 956                 return PTR_ERR(res->ahb_clk);
 957
 958         res->aux_clk = devm_clk_get(dev, "aux");
 959         if (IS_ERR(res->aux_clk))
 960                 return PTR_ERR(res->aux_clk);
 961
 962         for (i = 0; i < ARRAY_SIZE(rst_names); i++) {
 963                 res->rst[i] = devm_reset_control_get(dev, rst_names[i]);
 964                 if (IS_ERR(res->rst[i]))
 965                         return PTR_ERR(res->rst[i]);
 966         }
 967
 968         return 0;
 969 }
 970
 971 static void qcom_pcie_deinit_2_3_3(struct qcom_pcie *pcie)
 972 {
 973         struct qcom_pcie_resources_2_3_3 *res = &pcie->res.v2_3_3;
 974
 975         clk_disable_unprepare(res->iface);
 976         clk_disable_unprepare(res->axi_m_clk);
 977         clk_disable_unprepare(res->axi_s_clk);
 978         clk_disable_unprepare(res->ahb_clk);
 979         clk_disable_unprepare(res->aux_clk);
 980 }
 981
 982 static int qcom_pcie_init_2_3_3(struct qcom_pcie *pcie)
 983 {
 984         struct qcom_pcie_resources_2_3_3 *res = &pcie->res.v2_3_3;
 985         struct dw_pcie *pci = pcie->pci;
 986         struct device *dev = pci->dev;
 987         int i, ret;
 988
 989         for (i = 0; i < ARRAY_SIZE(res->rst); i++) {
 990                 ret = reset_control_assert(res->rst[i]);
 991                 if (ret) {
 992                         dev_err(dev, "reset #%d assert failed (%d)\n", i, ret);
 993                         return ret;
 994                 }
 995         }
 996
 997         usleep_range(2000, 2500);
 998
 999         for (i = 0; i < ARRAY_SIZE(res->rst); i++) {
1000                 ret = reset_control_deassert(res->rst[i]);
1001                 if (ret) {
1002                         dev_err(dev, "reset #%d deassert failed (%d)\n", i,
1003                                 ret);
1004                         return ret;
1005                 }
1006         }
1007
1008         /*
1009          * Don't have a way to see if the reset has completed.
1010          * Wait for some time.
1011          */
1012         usleep_range(2000, 2500);
1013
1014         ret = clk_prepare_enable(res->iface);
1015         if (ret) {
1016                 dev_err(dev, "cannot prepare/enable core clock\n");
1017                 goto err_clk_iface;
1018         }
1019
1020         ret = clk_prepare_enable(res->axi_m_clk);
1021         if (ret) {
1022                 dev_err(dev, "cannot prepare/enable core clock\n");
1023                 goto err_clk_axi_m;
1024         }
1025
1026         ret = clk_prepare_enable(res->axi_s_clk);
1027         if (ret) {
1028                 dev_err(dev, "cannot prepare/enable axi slave clock\n");
1029                 goto err_clk_axi_s;
1030         }
1031
1032         ret = clk_prepare_enable(res->ahb_clk);
1033         if (ret) {
1034                 dev_err(dev, "cannot prepare/enable ahb clock\n");
1035                 goto err_clk_ahb;
1036         }
1037
1038         ret = clk_prepare_enable(res->aux_clk);
1039         if (ret) {
1040                 dev_err(dev, "cannot prepare/enable aux clock\n");
1041                 goto err_clk_aux;
1042         }
1043
1044         return 0;
1045
1046 err_clk_aux:
1047         clk_disable_unprepare(res->ahb_clk);
1048 err_clk_ahb:
1049         clk_disable_unprepare(res->axi_s_clk);
1050 err_clk_axi_s:
1051         clk_disable_unprepare(res->axi_m_clk);
1052 err_clk_axi_m:
1053         clk_disable_unprepare(res->iface);
1054 err_clk_iface:
1055         /*
1056          * Not checking for failure, will anyway return
1057          * the original failure in 'ret'.
1058          */
1059         for (i = 0; i < ARRAY_SIZE(res->rst); i++)
1060                 reset_control_assert(res->rst[i]);
1061
1062         return ret;
1063 }
1064
1065 static int qcom_pcie_post_init_2_3_3(struct qcom_pcie *pcie)
1066 {
1067         struct dw_pcie *pci = pcie->pci;
1068         u16 offset = dw_pcie_find_capability(pci, PCI_CAP_ID_EXP);
1069         u32 val;
1070
1071         writel(SLV_ADDR_SPACE_SZ,
1072                 pcie->parf + PARF_SLV_ADDR_SPACE_SIZE_2_3_3);
1073
1074         val = readl(pcie->parf + PARF_PHY_CTRL);
1075         val &= ~PHY_TEST_PWR_DOWN;
1076         writel(val, pcie->parf + PARF_PHY_CTRL);
1077
1078         writel(0, pcie->parf + PARF_DBI_BASE_ADDR);
1079
1080         writel(MST_WAKEUP_EN | SLV_WAKEUP_EN | MSTR_ACLK_CGC_DIS
1081                 | SLV_ACLK_CGC_DIS | CORE_CLK_CGC_DIS |
1082                 AUX_PWR_DET | L23_CLK_RMV_DIS | L1_CLK_RMV_DIS,
1083                 pcie->parf + PARF_SYS_CTRL);
1084         writel(0, pcie->parf + PARF_Q2A_FLUSH);
1085
1086         writel(PCI_COMMAND_MASTER, pci->dbi_base + PCI_COMMAND);
1087         writel(DBI_RO_WR_EN, pci->dbi_base + MISC_CONTROL_1_REG);
1088         writel(PCIE_CAP_SLOT_VAL, pci->dbi_base + offset + PCI_EXP_SLTCAP);
1089
1090         val = readl(pci->dbi_base + offset + PCI_EXP_LNKCAP);
1091         val &= ~PCI_EXP_LNKCAP_ASPMS;
1092         writel(val, pci->dbi_base + offset + PCI_EXP_LNKCAP);
1093
1094         writel(PCI_EXP_DEVCTL2_COMP_TMOUT_DIS, pci->dbi_base + offset +
1095                 PCI_EXP_DEVCTL2);
1096
1097         return 0;
1098 }
1099
1100 static int qcom_pcie_get_resources_2_7_0(struct qcom_pcie *pcie)
1101 {
1102         struct qcom_pcie_resources_2_7_0 *res = &pcie->res.v2_7_0;
1103         struct dw_pcie *pci = pcie->pci;
1104         struct device *dev = pci->dev;
1105         unsigned int num_clks, num_opt_clks;
1106         unsigned int idx;
1107         int ret;
1108
1109         res->pci_reset = devm_reset_control_get_exclusive(dev, "pci");
1110         if (IS_ERR(res->pci_reset))
1111                 return PTR_ERR(res->pci_reset);
1112
1113         res->supplies[0].supply = "vdda";
1114         res->supplies[1].supply = "vddpe-3v3";
1115         ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(res->supplies),
1116                                       res->supplies);
1117         if (ret)
1118                 return ret;
1119
1120         idx = 0;
1121         res->clks[idx++].id = "aux";
1122         res->clks[idx++].id = "cfg";
1123         res->clks[idx++].id = "bus_master";
1124         res->clks[idx++].id = "bus_slave";
1125         res->clks[idx++].id = "slave_q2a";
1126
1127         num_clks = idx;
1128
1129         ret = devm_clk_bulk_get(dev, num_clks, res->clks);
1130         if (ret < 0)
1131                 return ret;
1132
1133         res->clks[idx++].id = "tbu";
1134         res->clks[idx++].id = "ddrss_sf_tbu";
1135         res->clks[idx++].id = "aggre0";
1136         res->clks[idx++].id = "aggre1";
1137         res->clks[idx++].id = "noc_aggr_4";
1138         res->clks[idx++].id = "noc_aggr_south_sf";
1139         res->clks[idx++].id = "cnoc_qx";
1140
1141         num_opt_clks = idx - num_clks;
1142         res->num_clks = idx;
1143
1144         ret = devm_clk_bulk_get_optional(dev, num_opt_clks, res->clks + num_clks);
1145         if (ret < 0)
1146                 return ret;
1147
1148         return 0;
1149 }
1150
1151 static int qcom_pcie_init_2_7_0(struct qcom_pcie *pcie)
1152 {
1153         struct qcom_pcie_resources_2_7_0 *res = &pcie->res.v2_7_0;
1154         struct dw_pcie *pci = pcie->pci;
1155         struct device *dev = pci->dev;
1156         u32 val;
1157         int ret;
1158
1159         ret = regulator_bulk_enable(ARRAY_SIZE(res->supplies), res->supplies);
1160         if (ret < 0) {
1161                 dev_err(dev, "cannot enable regulators\n");
1162                 return ret;
1163         }
1164
1165         ret = clk_bulk_prepare_enable(res->num_clks, res->clks);
1166         if (ret < 0)
1167                 goto err_disable_regulators;
1168
1169         ret = reset_control_assert(res->pci_reset);
1170         if (ret < 0) {
1171                 dev_err(dev, "cannot assert pci reset\n");
1172                 goto err_disable_clocks;
1173         }
1174
1175         usleep_range(1000, 1500);
1176
1177         ret = reset_control_deassert(res->pci_reset);
1178         if (ret < 0) {
1179                 dev_err(dev, "cannot deassert pci reset\n");
1180                 goto err_disable_clocks;
1181         }
1182
1183         /* Wait for reset to complete, required on SM8450 */
1184         usleep_range(1000, 1500);
1185
1186         /* configure PCIe to RC mode */
1187         writel(DEVICE_TYPE_RC, pcie->parf + PARF_DEVICE_TYPE);
1188
1189         /* enable PCIe clocks and resets */
1190         val = readl(pcie->parf + PARF_PHY_CTRL);
1191         val &= ~PHY_TEST_PWR_DOWN;
1192         writel(val, pcie->parf + PARF_PHY_CTRL);
1193
1194         /* change DBI base address */
1195         writel(0, pcie->parf + PARF_DBI_BASE_ADDR);
1196
1197         /* MAC PHY_POWERDOWN MUX DISABLE  */
1198         val = readl(pcie->parf + PARF_SYS_CTRL);
1199         val &= ~MAC_PHY_POWERDOWN_IN_P2_D_MUX_EN;
1200         writel(val, pcie->parf + PARF_SYS_CTRL);
1201
1202         val = readl(pcie->parf + PARF_MHI_CLOCK_RESET_CTRL);
1203         val |= BYPASS;
1204         writel(val, pcie->parf + PARF_MHI_CLOCK_RESET_CTRL);
1205
1206         /* Enable L1 and L1SS */
1207         val = readl(pcie->parf + PARF_PM_CTRL);
1208         val &= ~REQ_NOT_ENTR_L1;
1209         writel(val, pcie->parf + PARF_PM_CTRL);
1210
1211         val = readl(pcie->parf + PARF_AXI_MSTR_WR_ADDR_HALT_V2);
1212         val |= EN;
1213         writel(val, pcie->parf + PARF_AXI_MSTR_WR_ADDR_HALT_V2);
1214
1215         return 0;
1216 err_disable_clocks:
1217         clk_bulk_disable_unprepare(res->num_clks, res->clks);
1218 err_disable_regulators:
1219         regulator_bulk_disable(ARRAY_SIZE(res->supplies), res->supplies);
1220
1221         return ret;
1222 }
1223
1224 static void qcom_pcie_deinit_2_7_0(struct qcom_pcie *pcie)
1225 {
1226         struct qcom_pcie_resources_2_7_0 *res = &pcie->res.v2_7_0;
1227
1228         clk_bulk_disable_unprepare(res->num_clks, res->clks);
1229
1230         regulator_bulk_disable(ARRAY_SIZE(res->supplies), res->supplies);
1231 }
1232
1233 static int qcom_pcie_get_resources_2_9_0(struct qcom_pcie *pcie)
1234 {
1235         struct qcom_pcie_resources_2_9_0 *res = &pcie->res.v2_9_0;
1236         struct dw_pcie *pci = pcie->pci;
1237         struct device *dev = pci->dev;
1238         int ret;
1239
1240         res->clks[0].id = "iface";
1241         res->clks[1].id = "axi_m";
1242         res->clks[2].id = "axi_s";
1243         res->clks[3].id = "axi_bridge";
1244         res->clks[4].id = "rchng";
1245
1246         ret = devm_clk_bulk_get(dev, ARRAY_SIZE(res->clks), res->clks);
1247         if (ret < 0)
1248                 return ret;
1249
1250         res->rst = devm_reset_control_array_get_exclusive(dev);
1251         if (IS_ERR(res->rst))
1252                 return PTR_ERR(res->rst);
1253
1254         return 0;
1255 }
1256
1257 static void qcom_pcie_deinit_2_9_0(struct qcom_pcie *pcie)
1258 {
1259         struct qcom_pcie_resources_2_9_0 *res = &pcie->res.v2_9_0;
1260
1261         clk_bulk_disable_unprepare(ARRAY_SIZE(res->clks), res->clks);
1262 }
1263
1264 static int qcom_pcie_init_2_9_0(struct qcom_pcie *pcie)
1265 {
1266         struct qcom_pcie_resources_2_9_0 *res = &pcie->res.v2_9_0;
1267         struct device *dev = pcie->pci->dev;
1268         int ret;
1269
1270         ret = reset_control_assert(res->rst);
1271         if (ret) {
1272                 dev_err(dev, "reset assert failed (%d)\n", ret);
1273                 return ret;
1274         }
1275
1276         /*
1277          * Delay periods before and after reset deassert are working values
1278          * from downstream Codeaurora kernel
1279          */
1280         usleep_range(2000, 2500);
1281
1282         ret = reset_control_deassert(res->rst);
1283         if (ret) {
1284                 dev_err(dev, "reset deassert failed (%d)\n", ret);
1285                 return ret;
1286         }
1287
1288         usleep_range(2000, 2500);
1289
1290         return clk_bulk_prepare_enable(ARRAY_SIZE(res->clks), res->clks);
1291 }
1292
1293 static int qcom_pcie_post_init_2_9_0(struct qcom_pcie *pcie)
1294 {
1295         struct dw_pcie *pci = pcie->pci;
1296         u16 offset = dw_pcie_find_capability(pci, PCI_CAP_ID_EXP);
1297         u32 val;
1298         int i;
1299
1300         writel(SLV_ADDR_SPACE_SZ,
1301                 pcie->parf + PARF_SLV_ADDR_SPACE_SIZE);
1302
1303         val = readl(pcie->parf + PARF_PHY_CTRL);
1304         val &= ~PHY_TEST_PWR_DOWN;
1305         writel(val, pcie->parf + PARF_PHY_CTRL);
1306
1307         writel(0, pcie->parf + PARF_DBI_BASE_ADDR);
1308
1309         writel(DEVICE_TYPE_RC, pcie->parf + PARF_DEVICE_TYPE);
1310         writel(BYPASS | MSTR_AXI_CLK_EN | AHB_CLK_EN,
1311                 pcie->parf + PARF_MHI_CLOCK_RESET_CTRL);
1312         writel(GEN3_RELATED_OFF_RXEQ_RGRDLESS_RXTS |
1313                 GEN3_RELATED_OFF_GEN3_ZRXDC_NONCOMPL,
1314                 pci->dbi_base + GEN3_RELATED_OFF);
1315
1316         writel(MST_WAKEUP_EN | SLV_WAKEUP_EN | MSTR_ACLK_CGC_DIS |
1317                 SLV_ACLK_CGC_DIS | CORE_CLK_CGC_DIS |
1318                 AUX_PWR_DET | L23_CLK_RMV_DIS | L1_CLK_RMV_DIS,
1319                 pcie->parf + PARF_SYS_CTRL);
1320
1321         writel(0, pcie->parf + PARF_Q2A_FLUSH);
1322
1323         dw_pcie_dbi_ro_wr_en(pci);
1324         writel(PCIE_CAP_SLOT_VAL, pci->dbi_base + offset + PCI_EXP_SLTCAP);
1325
1326         val = readl(pci->dbi_base + offset + PCI_EXP_LNKCAP);
1327         val &= ~PCI_EXP_LNKCAP_ASPMS;
1328         writel(val, pci->dbi_base + offset + PCI_EXP_LNKCAP);
1329
1330         writel(PCI_EXP_DEVCTL2_COMP_TMOUT_DIS, pci->dbi_base + offset +
1331                         PCI_EXP_DEVCTL2);
1332
1333         for (i = 0; i < 256; i++)
1334                 writel(0, pcie->parf + PARF_BDF_TO_SID_TABLE_N + (4 * i));
1335
1336         return 0;
1337 }
1338
1339 static int qcom_pcie_link_up(struct dw_pcie *pci)
1340 {
1341         u16 offset = dw_pcie_find_capability(pci, PCI_CAP_ID_EXP);
1342         u16 val = readw(pci->dbi_base + offset + PCI_EXP_LNKSTA);
1343
1344         return !!(val & PCI_EXP_LNKSTA_DLLLA);
1345 }
1346
1347 static int qcom_pcie_config_sid_sm8250(struct qcom_pcie *pcie)
1348 {
1349         /* iommu map structure */
1350         struct {
1351                 u32 bdf;
1352                 u32 phandle;
1353                 u32 smmu_sid;
1354                 u32 smmu_sid_len;
1355         } *map;
1356         void __iomem *bdf_to_sid_base = pcie->parf + PARF_BDF_TO_SID_TABLE_N;
1357         struct device *dev = pcie->pci->dev;
1358         u8 qcom_pcie_crc8_table[CRC8_TABLE_SIZE];
1359         int i, nr_map, size = 0;
1360         u32 smmu_sid_base;
1361
1362         of_get_property(dev->of_node, "iommu-map", &size);
1363         if (!size)
1364                 return 0;
1365
1366         map = kzalloc(size, GFP_KERNEL);
1367         if (!map)
1368                 return -ENOMEM;
1369
1370         of_property_read_u32_array(dev->of_node,
1371                 "iommu-map", (u32 *)map, size / sizeof(u32));
1372
1373         nr_map = size / (sizeof(*map));
1374
1375         crc8_populate_msb(qcom_pcie_crc8_table, QCOM_PCIE_CRC8_POLYNOMIAL);
1376
1377         /* Registers need to be zero out first */
1378         memset_io(bdf_to_sid_base, 0, CRC8_TABLE_SIZE * sizeof(u32));
1379
1380         /* Extract the SMMU SID base from the first entry of iommu-map */
1381         smmu_sid_base = map[0].smmu_sid;
1382
1383         /* Look for an available entry to hold the mapping */
1384         for (i = 0; i < nr_map; i++) {
1385                 __be16 bdf_be = cpu_to_be16(map[i].bdf);
1386                 u32 val;
1387                 u8 hash;
1388
1389                 hash = crc8(qcom_pcie_crc8_table, (u8 *)&bdf_be, sizeof(bdf_be),
1390                         0);
1391
1392                 val = readl(bdf_to_sid_base + hash * sizeof(u32));
1393
1394                 /* If the register is already populated, look for next available entry */
1395                 while (val) {
1396                         u8 current_hash = hash++;
1397                         u8 next_mask = 0xff;
1398
1399                         /* If NEXT field is NULL then update it with next hash */
1400                         if (!(val & next_mask)) {
1401                                 val |= (u32)hash;
1402                                 writel(val, bdf_to_sid_base + current_hash * sizeof(u32));
1403                         }
1404
1405                         val = readl(bdf_to_sid_base + hash * sizeof(u32));
1406                 }
1407
1408                 /* BDF [31:16] | SID [15:8] | NEXT [7:0] */
1409                 val = map[i].bdf << 16 | (map[i].smmu_sid - smmu_sid_base) << 8 | 0;
1410                 writel(val, bdf_to_sid_base + hash * sizeof(u32));
1411         }
1412
1413         kfree(map);
1414
1415         return 0;
1416 }
1417
1418 static int qcom_pcie_host_init(struct dw_pcie_rp *pp)
1419 {
1420         struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
1421         struct qcom_pcie *pcie = to_qcom_pcie(pci);
1422         int ret;
1423
1424         qcom_ep_reset_assert(pcie);
1425
1426         ret = pcie->cfg->ops->init(pcie);
1427         if (ret)
1428                 return ret;
1429
1430         ret = phy_set_mode_ext(pcie->phy, PHY_MODE_PCIE, PHY_MODE_PCIE_RC);
1431         if (ret)
1432                 goto err_deinit;
1433
1434         ret = phy_power_on(pcie->phy);
1435         if (ret)
1436                 goto err_deinit;
1437
1438         if (pcie->cfg->ops->post_init) {
1439                 ret = pcie->cfg->ops->post_init(pcie);
1440                 if (ret)
1441                         goto err_disable_phy;
1442         }
1443
1444         qcom_ep_reset_deassert(pcie);
1445
1446         if (pcie->cfg->ops->config_sid) {
1447                 ret = pcie->cfg->ops->config_sid(pcie);
1448                 if (ret)
1449                         goto err_assert_reset;
1450         }
1451
1452         return 0;
1453
1454 err_assert_reset:
1455         qcom_ep_reset_assert(pcie);
1456 err_disable_phy:
1457         phy_power_off(pcie->phy);
1458 err_deinit:
1459         pcie->cfg->ops->deinit(pcie);
1460
1461         return ret;
1462 }
1463
1464 static void qcom_pcie_host_deinit(struct dw_pcie_rp *pp)
1465 {
1466         struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
1467         struct qcom_pcie *pcie = to_qcom_pcie(pci);
1468
1469         qcom_ep_reset_assert(pcie);
1470         phy_power_off(pcie->phy);
1471         pcie->cfg->ops->deinit(pcie);
1472 }
1473
1474 static const struct dw_pcie_host_ops qcom_pcie_dw_ops = {
1475         .host_init      = qcom_pcie_host_init,
1476         .host_deinit    = qcom_pcie_host_deinit,
1477 };
1478
1479 /* Qcom IP rev.: 2.1.0  Synopsys IP rev.: 4.01a */
1480 static const struct qcom_pcie_ops ops_2_1_0 = {
1481         .get_resources = qcom_pcie_get_resources_2_1_0,
1482         .init = qcom_pcie_init_2_1_0,
1483         .post_init = qcom_pcie_post_init_2_1_0,
1484         .deinit = qcom_pcie_deinit_2_1_0,
1485         .ltssm_enable = qcom_pcie_2_1_0_ltssm_enable,
1486 };
1487
1488 /* Qcom IP rev.: 1.0.0  Synopsys IP rev.: 4.11a */
1489 static const struct qcom_pcie_ops ops_1_0_0 = {
1490         .get_resources = qcom_pcie_get_resources_1_0_0,
1491         .init = qcom_pcie_init_1_0_0,
1492         .post_init = qcom_pcie_post_init_1_0_0,
1493         .deinit = qcom_pcie_deinit_1_0_0,
1494         .ltssm_enable = qcom_pcie_2_1_0_ltssm_enable,
1495 };
1496
1497 /* Qcom IP rev.: 2.3.2  Synopsys IP rev.: 4.21a */
1498 static const struct qcom_pcie_ops ops_2_3_2 = {
1499         .get_resources = qcom_pcie_get_resources_2_3_2,
1500         .init = qcom_pcie_init_2_3_2,
1501         .post_init = qcom_pcie_post_init_2_3_2,
1502         .deinit = qcom_pcie_deinit_2_3_2,
1503         .ltssm_enable = qcom_pcie_2_3_2_ltssm_enable,
1504 };
1505
1506 /* Qcom IP rev.: 2.4.0  Synopsys IP rev.: 4.20a */
1507 static const struct qcom_pcie_ops ops_2_4_0 = {
1508         .get_resources = qcom_pcie_get_resources_2_4_0,
1509         .init = qcom_pcie_init_2_4_0,
1510         .post_init = qcom_pcie_post_init_2_4_0,
1511         .deinit = qcom_pcie_deinit_2_4_0,
1512         .ltssm_enable = qcom_pcie_2_3_2_ltssm_enable,
1513 };
1514
1515 /* Qcom IP rev.: 2.3.3  Synopsys IP rev.: 4.30a */
1516 static const struct qcom_pcie_ops ops_2_3_3 = {
1517         .get_resources = qcom_pcie_get_resources_2_3_3,
1518         .init = qcom_pcie_init_2_3_3,
1519         .post_init = qcom_pcie_post_init_2_3_3,
1520         .deinit = qcom_pcie_deinit_2_3_3,
1521         .ltssm_enable = qcom_pcie_2_3_2_ltssm_enable,
1522 };
1523
1524 /* Qcom IP rev.: 2.7.0  Synopsys IP rev.: 4.30a */
1525 static const struct qcom_pcie_ops ops_2_7_0 = {
1526         .get_resources = qcom_pcie_get_resources_2_7_0,
1527         .init = qcom_pcie_init_2_7_0,
1528         .deinit = qcom_pcie_deinit_2_7_0,
1529         .ltssm_enable = qcom_pcie_2_3_2_ltssm_enable,
1530 };
1531
1532 /* Qcom IP rev.: 1.9.0 */
1533 static const struct qcom_pcie_ops ops_1_9_0 = {
1534         .get_resources = qcom_pcie_get_resources_2_7_0,
1535         .init = qcom_pcie_init_2_7_0,
1536         .deinit = qcom_pcie_deinit_2_7_0,
1537         .ltssm_enable = qcom_pcie_2_3_2_ltssm_enable,
1538         .config_sid = qcom_pcie_config_sid_sm8250,
1539 };
1540
1541 /* Qcom IP rev.: 2.9.0  Synopsys IP rev.: 5.00a */
1542 static const struct qcom_pcie_ops ops_2_9_0 = {
1543         .get_resources = qcom_pcie_get_resources_2_9_0,
1544         .init = qcom_pcie_init_2_9_0,
1545         .post_init = qcom_pcie_post_init_2_9_0,
1546         .deinit = qcom_pcie_deinit_2_9_0,
1547         .ltssm_enable = qcom_pcie_2_3_2_ltssm_enable,
1548 };
1549
1550 static const struct qcom_pcie_cfg cfg_1_0_0 = {
1551         .ops = &ops_1_0_0,
1552 };
1553
1554 static const struct qcom_pcie_cfg cfg_1_9_0 = {
1555         .ops = &ops_1_9_0,
1556 };
1557
1558 static const struct qcom_pcie_cfg cfg_2_1_0 = {
1559         .ops = &ops_2_1_0,
1560 };
1561
1562 static const struct qcom_pcie_cfg cfg_2_3_2 = {
1563         .ops = &ops_2_3_2,
1564 };
1565
1566 static const struct qcom_pcie_cfg cfg_2_3_3 = {
1567         .ops = &ops_2_3_3,
1568 };
1569
1570 static const struct qcom_pcie_cfg cfg_2_4_0 = {
1571         .ops = &ops_2_4_0,
1572 };
1573
1574 static const struct qcom_pcie_cfg cfg_2_7_0 = {
1575         .ops = &ops_2_7_0,
1576 };
1577
1578 static const struct qcom_pcie_cfg cfg_2_9_0 = {
1579         .ops = &ops_2_9_0,
1580 };
1581
1582 static const struct dw_pcie_ops dw_pcie_ops = {
1583         .link_up = qcom_pcie_link_up,
1584         .start_link = qcom_pcie_start_link,
1585 };
1586
1587 static int qcom_pcie_icc_init(struct qcom_pcie *pcie)
1588 {
1589         struct dw_pcie *pci = pcie->pci;
1590         int ret;
1591
1592         pcie->icc_mem = devm_of_icc_get(pci->dev, "pcie-mem");
1593         if (IS_ERR(pcie->icc_mem))
1594                 return PTR_ERR(pcie->icc_mem);
1595
1596         /*
1597          * Some Qualcomm platforms require interconnect bandwidth constraints
1598          * to be set before enabling interconnect clocks.
1599          *
1600          * Set an initial peak bandwidth corresponding to single-lane Gen 1
1601          * for the pcie-mem path.
1602          */
1603         ret = icc_set_bw(pcie->icc_mem, 0, MBps_to_icc(250));
1604         if (ret) {
1605                 dev_err(pci->dev, "failed to set interconnect bandwidth: %d\n",
1606                         ret);
1607                 return ret;
1608         }
1609
1610         return 0;
1611 }
1612
1613 static void qcom_pcie_icc_update(struct qcom_pcie *pcie)
1614 {
1615         struct dw_pcie *pci = pcie->pci;
1616         u32 offset, status, bw;
1617         int speed, width;
1618         int ret;
1619
1620         if (!pcie->icc_mem)
1621                 return;
1622
1623         offset = dw_pcie_find_capability(pci, PCI_CAP_ID_EXP);
1624         status = readw(pci->dbi_base + offset + PCI_EXP_LNKSTA);
1625
1626         /* Only update constraints if link is up. */
1627         if (!(status & PCI_EXP_LNKSTA_DLLLA))
1628                 return;
1629
1630         speed = FIELD_GET(PCI_EXP_LNKSTA_CLS, status);
1631         width = FIELD_GET(PCI_EXP_LNKSTA_NLW, status);
1632
1633         switch (speed) {
1634         case 1:
1635                 bw = MBps_to_icc(250);
1636                 break;
1637         case 2:
1638                 bw = MBps_to_icc(500);
1639                 break;
1640         default:
1641                 WARN_ON_ONCE(1);
1642                 fallthrough;
1643         case 3:
1644                 bw = MBps_to_icc(985);
1645                 break;
1646         }
1647
1648         ret = icc_set_bw(pcie->icc_mem, 0, width * bw);
1649         if (ret) {
1650                 dev_err(pci->dev, "failed to set interconnect bandwidth: %d\n",
1651                         ret);
1652         }
1653 }
1654
1655 static int qcom_pcie_probe(struct platform_device *pdev)
1656 {
1657         struct device *dev = &pdev->dev;
1658         struct dw_pcie_rp *pp;
1659         struct dw_pcie *pci;
1660         struct qcom_pcie *pcie;
1661         const struct qcom_pcie_cfg *pcie_cfg;
1662         int ret;
1663
1664         pcie_cfg = of_device_get_match_data(dev);
1665         if (!pcie_cfg || !pcie_cfg->ops) {
1666                 dev_err(dev, "Invalid platform data\n");
1667                 return -EINVAL;
1668         }
1669
1670         pcie = devm_kzalloc(dev, sizeof(*pcie), GFP_KERNEL);
1671         if (!pcie)
1672                 return -ENOMEM;
1673
1674         pci = devm_kzalloc(dev, sizeof(*pci), GFP_KERNEL);
1675         if (!pci)
1676                 return -ENOMEM;
1677
1678         pm_runtime_enable(dev);
1679         ret = pm_runtime_get_sync(dev);
1680         if (ret < 0)
1681                 goto err_pm_runtime_put;
1682
1683         pci->dev = dev;
1684         pci->ops = &dw_pcie_ops;
1685         pp = &pci->pp;
1686
1687         pcie->pci = pci;
1688
1689         pcie->cfg = pcie_cfg;
1690
1691         pcie->reset = devm_gpiod_get_optional(dev, "perst", GPIOD_OUT_HIGH);
1692         if (IS_ERR(pcie->reset)) {
1693                 ret = PTR_ERR(pcie->reset);
1694                 goto err_pm_runtime_put;
1695         }
1696
1697         pcie->parf = devm_platform_ioremap_resource_byname(pdev, "parf");
1698         if (IS_ERR(pcie->parf)) {
1699                 ret = PTR_ERR(pcie->parf);
1700                 goto err_pm_runtime_put;
1701         }
1702
1703         pcie->elbi = devm_platform_ioremap_resource_byname(pdev, "elbi");
1704         if (IS_ERR(pcie->elbi)) {
1705                 ret = PTR_ERR(pcie->elbi);
1706                 goto err_pm_runtime_put;
1707         }
1708
1709         pcie->phy = devm_phy_optional_get(dev, "pciephy");
1710         if (IS_ERR(pcie->phy)) {
1711                 ret = PTR_ERR(pcie->phy);
1712                 goto err_pm_runtime_put;
1713         }
1714
1715         ret = qcom_pcie_icc_init(pcie);
1716         if (ret)
1717                 goto err_pm_runtime_put;
1718
1719         ret = pcie->cfg->ops->get_resources(pcie);
1720         if (ret)
1721                 goto err_pm_runtime_put;
1722
1723         pp->ops = &qcom_pcie_dw_ops;
1724
1725         ret = phy_init(pcie->phy);
1726         if (ret)
1727                 goto err_pm_runtime_put;
1728
1729         platform_set_drvdata(pdev, pcie);
1730
1731         ret = dw_pcie_host_init(pp);
1732         if (ret) {
1733                 dev_err(dev, "cannot initialize host\n");
1734                 goto err_phy_exit;
1735         }
1736
1737         qcom_pcie_icc_update(pcie);
1738
1739         return 0;
1740
1741 err_phy_exit:
1742         phy_exit(pcie->phy);
1743 err_pm_runtime_put:
1744         pm_runtime_put(dev);
1745         pm_runtime_disable(dev);
1746
1747         return ret;
1748 }
1749
1750 static const struct of_device_id qcom_pcie_match[] = {
1751         { .compatible = "qcom,pcie-apq8064", .data = &cfg_2_1_0 },
1752         { .compatible = "qcom,pcie-apq8084", .data = &cfg_1_0_0 },
1753         { .compatible = "qcom,pcie-ipq4019", .data = &cfg_2_4_0 },
1754         { .compatible = "qcom,pcie-ipq6018", .data = &cfg_2_9_0 },
1755         { .compatible = "qcom,pcie-ipq8064", .data = &cfg_2_1_0 },
1756         { .compatible = "qcom,pcie-ipq8064-v2", .data = &cfg_2_1_0 },
1757         { .compatible = "qcom,pcie-ipq8074", .data = &cfg_2_3_3 },
1758         { .compatible = "qcom,pcie-ipq8074-gen3", .data = &cfg_2_9_0 },
1759         { .compatible = "qcom,pcie-msm8996", .data = &cfg_2_3_2 },
1760         { .compatible = "qcom,pcie-qcs404", .data = &cfg_2_4_0 },
1761         { .compatible = "qcom,pcie-sa8540p", .data = &cfg_1_9_0 },
1762         { .compatible = "qcom,pcie-sc7280", .data = &cfg_1_9_0 },
1763         { .compatible = "qcom,pcie-sc8180x", .data = &cfg_1_9_0 },
1764         { .compatible = "qcom,pcie-sc8280xp", .data = &cfg_1_9_0 },
1765         { .compatible = "qcom,pcie-sdm845", .data = &cfg_2_7_0 },
1766         { .compatible = "qcom,pcie-sm8150", .data = &cfg_1_9_0 },
1767         { .compatible = "qcom,pcie-sm8250", .data = &cfg_1_9_0 },
1768         { .compatible = "qcom,pcie-sm8350", .data = &cfg_1_9_0 },
1769         { .compatible = "qcom,pcie-sm8450-pcie0", .data = &cfg_1_9_0 },
1770         { .compatible = "qcom,pcie-sm8450-pcie1", .data = &cfg_1_9_0 },
1771         { }
1772 };
1773
1774 static void qcom_fixup_class(struct pci_dev *dev)
1775 {
1776         dev->class = PCI_CLASS_BRIDGE_PCI_NORMAL;
1777 }
1778 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_QCOM, 0x0101, qcom_fixup_class);
1779 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_QCOM, 0x0104, qcom_fixup_class);
1780 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_QCOM, 0x0106, qcom_fixup_class);
1781 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_QCOM, 0x0107, qcom_fixup_class);
1782 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_QCOM, 0x0302, qcom_fixup_class);
1783 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_QCOM, 0x1000, qcom_fixup_class);
1784 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_QCOM, 0x1001, qcom_fixup_class);
1785
1786 static struct platform_driver qcom_pcie_driver = {
1787         .probe = qcom_pcie_probe,
1788         .driver = {
1789                 .name = "qcom-pcie",
1790                 .suppress_bind_attrs = true,
1791                 .of_match_table = qcom_pcie_match,
1792         },
1793 };
1794 builtin_platform_driver(qcom_pcie_driver);