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

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