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