drivers/pci/dwc/pcie-qcom.c

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