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