drivers/pci/host/pci-tegra.c

   1 /*
   2  * PCIe host controller driver for Tegra SoCs
   3  *
   4  * Copyright (c) 2010, CompuLab, Ltd.
   5  * Author: Mike Rapoport <mike@compulab.co.il>
   6  *
   7  * Based on NVIDIA PCIe driver
   8  * Copyright (c) 2008-2009, NVIDIA Corporation.
   9  *
  10  * Bits taken from arch/arm/mach-dove/pcie.c
  11  *
  12  * Author: Thierry Reding <treding@nvidia.com>
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful, but WITHOUT
  20  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  21  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  22  * more details.
  23  *
  24  * You should have received a copy of the GNU General Public License along
  25  * with this program; if not, write to the Free Software Foundation, Inc.,
  26  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  27  */
  28
  29 #include <linux/clk.h>
  30 #include <linux/debugfs.h>
  31 #include <linux/delay.h>
  32 #include <linux/export.h>
  33 #include <linux/interrupt.h>
  34 #include <linux/irq.h>
  35 #include <linux/irqdomain.h>
  36 #include <linux/kernel.h>
  37 #include <linux/init.h>
  38 #include <linux/msi.h>
  39 #include <linux/of_address.h>
  40 #include <linux/of_pci.h>
  41 #include <linux/of_platform.h>
  42 #include <linux/pci.h>
  43 #include <linux/phy/phy.h>
  44 #include <linux/platform_device.h>
  45 #include <linux/reset.h>
  46 #include <linux/sizes.h>
  47 #include <linux/slab.h>
  48 #include <linux/vmalloc.h>
  49 #include <linux/regulator/consumer.h>
  50
  51 #include <soc/tegra/cpuidle.h>
  52 #include <soc/tegra/pmc.h>
  53
  54 #include <asm/mach/irq.h>
  55 #include <asm/mach/map.h>
  56 #include <asm/mach/pci.h>
  57
  58 #define INT_PCI_MSI_NR (8 * 32)
  59
  60 /* register definitions */
  61
  62 #define AFI_AXI_BAR0_SZ 0x00
  63 #define AFI_AXI_BAR1_SZ 0x04
  64 #define AFI_AXI_BAR2_SZ 0x08
  65 #define AFI_AXI_BAR3_SZ 0x0c
  66 #define AFI_AXI_BAR4_SZ 0x10
  67 #define AFI_AXI_BAR5_SZ 0x14
  68
  69 #define AFI_AXI_BAR0_START      0x18
  70 #define AFI_AXI_BAR1_START      0x1c
  71 #define AFI_AXI_BAR2_START      0x20
  72 #define AFI_AXI_BAR3_START      0x24
  73 #define AFI_AXI_BAR4_START      0x28
  74 #define AFI_AXI_BAR5_START      0x2c
  75
  76 #define AFI_FPCI_BAR0   0x30
  77 #define AFI_FPCI_BAR1   0x34
  78 #define AFI_FPCI_BAR2   0x38
  79 #define AFI_FPCI_BAR3   0x3c
  80 #define AFI_FPCI_BAR4   0x40
  81 #define AFI_FPCI_BAR5   0x44
  82
  83 #define AFI_CACHE_BAR0_SZ       0x48
  84 #define AFI_CACHE_BAR0_ST       0x4c
  85 #define AFI_CACHE_BAR1_SZ       0x50
  86 #define AFI_CACHE_BAR1_ST       0x54
  87
  88 #define AFI_MSI_BAR_SZ          0x60
  89 #define AFI_MSI_FPCI_BAR_ST     0x64
  90 #define AFI_MSI_AXI_BAR_ST      0x68
  91
  92 #define AFI_MSI_VEC0            0x6c
  93 #define AFI_MSI_VEC1            0x70
  94 #define AFI_MSI_VEC2            0x74
  95 #define AFI_MSI_VEC3            0x78
  96 #define AFI_MSI_VEC4            0x7c
  97 #define AFI_MSI_VEC5            0x80
  98 #define AFI_MSI_VEC6            0x84
  99 #define AFI_MSI_VEC7            0x88
 100
 101 #define AFI_MSI_EN_VEC0         0x8c
 102 #define AFI_MSI_EN_VEC1         0x90
 103 #define AFI_MSI_EN_VEC2         0x94
 104 #define AFI_MSI_EN_VEC3         0x98
 105 #define AFI_MSI_EN_VEC4         0x9c
 106 #define AFI_MSI_EN_VEC5         0xa0
 107 #define AFI_MSI_EN_VEC6         0xa4
 108 #define AFI_MSI_EN_VEC7         0xa8
 109
 110 #define AFI_CONFIGURATION               0xac
 111 #define  AFI_CONFIGURATION_EN_FPCI      (1 << 0)
 112
 113 #define AFI_FPCI_ERROR_MASKS    0xb0
 114
 115 #define AFI_INTR_MASK           0xb4
 116 #define  AFI_INTR_MASK_INT_MASK (1 << 0)
 117 #define  AFI_INTR_MASK_MSI_MASK (1 << 8)
 118
 119 #define AFI_INTR_CODE                   0xb8
 120 #define  AFI_INTR_CODE_MASK             0xf
 121 #define  AFI_INTR_INI_SLAVE_ERROR       1
 122 #define  AFI_INTR_INI_DECODE_ERROR      2
 123 #define  AFI_INTR_TARGET_ABORT          3
 124 #define  AFI_INTR_MASTER_ABORT          4
 125 #define  AFI_INTR_INVALID_WRITE         5
 126 #define  AFI_INTR_LEGACY                6
 127 #define  AFI_INTR_FPCI_DECODE_ERROR     7
 128 #define  AFI_INTR_AXI_DECODE_ERROR      8
 129 #define  AFI_INTR_FPCI_TIMEOUT          9
 130 #define  AFI_INTR_PE_PRSNT_SENSE        10
 131 #define  AFI_INTR_PE_CLKREQ_SENSE       11
 132 #define  AFI_INTR_CLKCLAMP_SENSE        12
 133 #define  AFI_INTR_RDY4PD_SENSE          13
 134 #define  AFI_INTR_P2P_ERROR             14
 135
 136 #define AFI_INTR_SIGNATURE      0xbc
 137 #define AFI_UPPER_FPCI_ADDRESS  0xc0
 138 #define AFI_SM_INTR_ENABLE      0xc4
 139 #define  AFI_SM_INTR_INTA_ASSERT        (1 << 0)
 140 #define  AFI_SM_INTR_INTB_ASSERT        (1 << 1)
 141 #define  AFI_SM_INTR_INTC_ASSERT        (1 << 2)
 142 #define  AFI_SM_INTR_INTD_ASSERT        (1 << 3)
 143 #define  AFI_SM_INTR_INTA_DEASSERT      (1 << 4)
 144 #define  AFI_SM_INTR_INTB_DEASSERT      (1 << 5)
 145 #define  AFI_SM_INTR_INTC_DEASSERT      (1 << 6)
 146 #define  AFI_SM_INTR_INTD_DEASSERT      (1 << 7)
 147
 148 #define AFI_AFI_INTR_ENABLE             0xc8
 149 #define  AFI_INTR_EN_INI_SLVERR         (1 << 0)
 150 #define  AFI_INTR_EN_INI_DECERR         (1 << 1)
 151 #define  AFI_INTR_EN_TGT_SLVERR         (1 << 2)
 152 #define  AFI_INTR_EN_TGT_DECERR         (1 << 3)
 153 #define  AFI_INTR_EN_TGT_WRERR          (1 << 4)
 154 #define  AFI_INTR_EN_DFPCI_DECERR       (1 << 5)
 155 #define  AFI_INTR_EN_AXI_DECERR         (1 << 6)
 156 #define  AFI_INTR_EN_FPCI_TIMEOUT       (1 << 7)
 157 #define  AFI_INTR_EN_PRSNT_SENSE        (1 << 8)
 158
 159 #define AFI_PCIE_CONFIG                                 0x0f8
 160 #define  AFI_PCIE_CONFIG_PCIE_DISABLE(x)                (1 << ((x) + 1))
 161 #define  AFI_PCIE_CONFIG_PCIE_DISABLE_ALL               0xe
 162 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_MASK       (0xf << 20)
 163 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_SINGLE     (0x0 << 20)
 164 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_420        (0x0 << 20)
 165 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_X2_X1      (0x0 << 20)
 166 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_DUAL       (0x1 << 20)
 167 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_222        (0x1 << 20)
 168 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_X4_X1      (0x1 << 20)
 169 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_411        (0x2 << 20)
 170
 171 #define AFI_FUSE                        0x104
 172 #define  AFI_FUSE_PCIE_T0_GEN2_DIS      (1 << 2)
 173
 174 #define AFI_PEX0_CTRL                   0x110
 175 #define AFI_PEX1_CTRL                   0x118
 176 #define AFI_PEX2_CTRL                   0x128
 177 #define  AFI_PEX_CTRL_RST               (1 << 0)
 178 #define  AFI_PEX_CTRL_CLKREQ_EN         (1 << 1)
 179 #define  AFI_PEX_CTRL_REFCLK_EN         (1 << 3)
 180 #define  AFI_PEX_CTRL_OVERRIDE_EN       (1 << 4)
 181
 182 #define AFI_PLLE_CONTROL                0x160
 183 #define  AFI_PLLE_CONTROL_BYPASS_PADS2PLLE_CONTROL (1 << 9)
 184 #define  AFI_PLLE_CONTROL_PADS2PLLE_CONTROL_EN (1 << 1)
 185
 186 #define AFI_PEXBIAS_CTRL_0              0x168
 187
 188 #define RP_VEND_XP      0x00000f00
 189 #define  RP_VEND_XP_DL_UP       (1 << 30)
 190
 191 #define RP_VEND_CTL2 0x00000fa8
 192 #define  RP_VEND_CTL2_PCA_ENABLE (1 << 7)
 193
 194 #define RP_PRIV_MISC    0x00000fe0
 195 #define  RP_PRIV_MISC_PRSNT_MAP_EP_PRSNT (0xe << 0)
 196 #define  RP_PRIV_MISC_PRSNT_MAP_EP_ABSNT (0xf << 0)
 197
 198 #define RP_LINK_CONTROL_STATUS                  0x00000090
 199 #define  RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE  0x20000000
 200 #define  RP_LINK_CONTROL_STATUS_LINKSTAT_MASK   0x3fff0000
 201
 202 #define PADS_CTL_SEL            0x0000009c
 203
 204 #define PADS_CTL                0x000000a0
 205 #define  PADS_CTL_IDDQ_1L       (1 << 0)
 206 #define  PADS_CTL_TX_DATA_EN_1L (1 << 6)
 207 #define  PADS_CTL_RX_DATA_EN_1L (1 << 10)
 208
 209 #define PADS_PLL_CTL_TEGRA20                    0x000000b8
 210 #define PADS_PLL_CTL_TEGRA30                    0x000000b4
 211 #define  PADS_PLL_CTL_RST_B4SM                  (1 << 1)
 212 #define  PADS_PLL_CTL_LOCKDET                   (1 << 8)
 213 #define  PADS_PLL_CTL_REFCLK_MASK               (0x3 << 16)
 214 #define  PADS_PLL_CTL_REFCLK_INTERNAL_CML       (0 << 16)
 215 #define  PADS_PLL_CTL_REFCLK_INTERNAL_CMOS      (1 << 16)
 216 #define  PADS_PLL_CTL_REFCLK_EXTERNAL           (2 << 16)
 217 #define  PADS_PLL_CTL_TXCLKREF_MASK             (0x1 << 20)
 218 #define  PADS_PLL_CTL_TXCLKREF_DIV10            (0 << 20)
 219 #define  PADS_PLL_CTL_TXCLKREF_DIV5             (1 << 20)
 220 #define  PADS_PLL_CTL_TXCLKREF_BUF_EN           (1 << 22)
 221
 222 #define PADS_REFCLK_CFG0                        0x000000c8
 223 #define PADS_REFCLK_CFG1                        0x000000cc
 224 #define PADS_REFCLK_BIAS                        0x000000d0
 225
 226 /*
 227  * Fields in PADS_REFCLK_CFG*. Those registers form an array of 16-bit
 228  * entries, one entry per PCIe port. These field definitions and desired
 229  * values aren't in the TRM, but do come from NVIDIA.
 230  */
 231 #define PADS_REFCLK_CFG_TERM_SHIFT              2  /* 6:2 */
 232 #define PADS_REFCLK_CFG_E_TERM_SHIFT            7
 233 #define PADS_REFCLK_CFG_PREDI_SHIFT             8  /* 11:8 */
 234 #define PADS_REFCLK_CFG_DRVI_SHIFT              12 /* 15:12 */
 235
 236 struct tegra_msi {
 237         struct msi_controller chip;
 238         DECLARE_BITMAP(used, INT_PCI_MSI_NR);
 239         struct irq_domain *domain;
 240         unsigned long pages;
 241         struct mutex lock;
 242         int irq;
 243 };
 244
 245 /* used to differentiate between Tegra SoC generations */
 246 struct tegra_pcie_soc {
 247         unsigned int num_ports;
 248         unsigned int msi_base_shift;
 249         u32 pads_pll_ctl;
 250         u32 tx_ref_sel;
 251         u32 pads_refclk_cfg0;
 252         u32 pads_refclk_cfg1;
 253         bool has_pex_clkreq_en;
 254         bool has_pex_bias_ctrl;
 255         bool has_intr_prsnt_sense;
 256         bool has_cml_clk;
 257         bool has_gen2;
 258         bool force_pca_enable;
 259 };
 260
 261 static inline struct tegra_msi *to_tegra_msi(struct msi_controller *chip)
 262 {
 263         return container_of(chip, struct tegra_msi, chip);
 264 }
 265
 266 struct tegra_pcie {
 267         struct device *dev;
 268
 269         void __iomem *pads;
 270         void __iomem *afi;
 271         int irq;
 272
 273         struct list_head buses;
 274         struct resource *cs;
 275
 276         struct resource io;
 277         struct resource pio;
 278         struct resource mem;
 279         struct resource prefetch;
 280         struct resource busn;
 281
 282         struct {
 283                 resource_size_t mem;
 284                 resource_size_t io;
 285         } offset;
 286
 287         struct clk *pex_clk;
 288         struct clk *afi_clk;
 289         struct clk *pll_e;
 290         struct clk *cml_clk;
 291
 292         struct reset_control *pex_rst;
 293         struct reset_control *afi_rst;
 294         struct reset_control *pcie_xrst;
 295
 296         bool legacy_phy;
 297         struct phy *phy;
 298
 299         struct tegra_msi msi;
 300
 301         struct list_head ports;
 302         u32 xbar_config;
 303
 304         struct regulator_bulk_data *supplies;
 305         unsigned int num_supplies;
 306
 307         const struct tegra_pcie_soc *soc;
 308         struct dentry *debugfs;
 309 };
 310
 311 struct tegra_pcie_port {
 312         struct tegra_pcie *pcie;
 313         struct device_node *np;
 314         struct list_head list;
 315         struct resource regs;
 316         void __iomem *base;
 317         unsigned int index;
 318         unsigned int lanes;
 319
 320         struct phy **phys;
 321 };
 322
 323 struct tegra_pcie_bus {
 324         struct vm_struct *area;
 325         struct list_head list;
 326         unsigned int nr;
 327 };
 328
 329 static inline void afi_writel(struct tegra_pcie *pcie, u32 value,
 330                               unsigned long offset)
 331 {
 332         writel(value, pcie->afi + offset);
 333 }
 334
 335 static inline u32 afi_readl(struct tegra_pcie *pcie, unsigned long offset)
 336 {
 337         return readl(pcie->afi + offset);
 338 }
 339
 340 static inline void pads_writel(struct tegra_pcie *pcie, u32 value,
 341                                unsigned long offset)
 342 {
 343         writel(value, pcie->pads + offset);
 344 }
 345
 346 static inline u32 pads_readl(struct tegra_pcie *pcie, unsigned long offset)
 347 {
 348         return readl(pcie->pads + offset);
 349 }
 350
 351 /*
 352  * The configuration space mapping on Tegra is somewhat similar to the ECAM
 353  * defined by PCIe. However it deviates a bit in how the 4 bits for extended
 354  * register accesses are mapped:
 355  *
 356  *    [27:24] extended register number
 357  *    [23:16] bus number
 358  *    [15:11] device number
 359  *    [10: 8] function number
 360  *    [ 7: 0] register number
 361  *
 362  * Mapping the whole extended configuration space would require 256 MiB of
 363  * virtual address space, only a small part of which will actually be used.
 364  * To work around this, a 1 MiB of virtual addresses are allocated per bus
 365  * when the bus is first accessed. When the physical range is mapped, the
 366  * the bus number bits are hidden so that the extended register number bits
 367  * appear as bits [19:16]. Therefore the virtual mapping looks like this:
 368  *
 369  *    [19:16] extended register number
 370  *    [15:11] device number
 371  *    [10: 8] function number
 372  *    [ 7: 0] register number
 373  *
 374  * This is achieved by stitching together 16 chunks of 64 KiB of physical
 375  * address space via the MMU.
 376  */
 377 static unsigned long tegra_pcie_conf_offset(unsigned int devfn, int where)
 378 {
 379         return ((where & 0xf00) << 8) | (PCI_SLOT(devfn) << 11) |
 380                (PCI_FUNC(devfn) << 8) | (where & 0xfc);
 381 }
 382
 383 static struct tegra_pcie_bus *tegra_pcie_bus_alloc(struct tegra_pcie *pcie,
 384                                                    unsigned int busnr)
 385 {
 386         struct device *dev = pcie->dev;
 387         pgprot_t prot = __pgprot(L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_DIRTY |
 388                                  L_PTE_XN | L_PTE_MT_DEV_SHARED | L_PTE_SHARED);
 389         phys_addr_t cs = pcie->cs->start;
 390         struct tegra_pcie_bus *bus;
 391         unsigned int i;
 392         int err;
 393
 394         bus = kzalloc(sizeof(*bus), GFP_KERNEL);
 395         if (!bus)
 396                 return ERR_PTR(-ENOMEM);
 397
 398         INIT_LIST_HEAD(&bus->list);
 399         bus->nr = busnr;
 400
 401         /* allocate 1 MiB of virtual addresses */
 402         bus->area = get_vm_area(SZ_1M, VM_IOREMAP);
 403         if (!bus->area) {
 404                 err = -ENOMEM;
 405                 goto free;
 406         }
 407
 408         /* map each of the 16 chunks of 64 KiB each */
 409         for (i = 0; i < 16; i++) {
 410                 unsigned long virt = (unsigned long)bus->area->addr +
 411                                      i * SZ_64K;
 412                 phys_addr_t phys = cs + i * SZ_16M + busnr * SZ_64K;
 413
 414                 err = ioremap_page_range(virt, virt + SZ_64K, phys, prot);
 415                 if (err < 0) {
 416                         dev_err(dev, "ioremap_page_range() failed: %d\n", err);
 417                         goto unmap;
 418                 }
 419         }
 420
 421         return bus;
 422
 423 unmap:
 424         vunmap(bus->area->addr);
 425 free:
 426         kfree(bus);
 427         return ERR_PTR(err);
 428 }
 429
 430 static int tegra_pcie_add_bus(struct pci_bus *bus)
 431 {
 432         struct pci_host_bridge *host = pci_find_host_bridge(bus);
 433         struct tegra_pcie *pcie = pci_host_bridge_priv(host);
 434         struct tegra_pcie_bus *b;
 435
 436         b = tegra_pcie_bus_alloc(pcie, bus->number);
 437         if (IS_ERR(b))
 438                 return PTR_ERR(b);
 439
 440         list_add_tail(&b->list, &pcie->buses);
 441
 442         return 0;
 443 }
 444
 445 static void tegra_pcie_remove_bus(struct pci_bus *child)
 446 {
 447         struct pci_host_bridge *host = pci_find_host_bridge(child);
 448         struct tegra_pcie *pcie = pci_host_bridge_priv(host);
 449         struct tegra_pcie_bus *bus, *tmp;
 450
 451         list_for_each_entry_safe(bus, tmp, &pcie->buses, list) {
 452                 if (bus->nr == child->number) {
 453                         vunmap(bus->area->addr);
 454                         list_del(&bus->list);
 455                         kfree(bus);
 456                         break;
 457                 }
 458         }
 459 }
 460
 461 static void __iomem *tegra_pcie_map_bus(struct pci_bus *bus,
 462                                         unsigned int devfn,
 463                                         int where)
 464 {
 465         struct pci_host_bridge *host = pci_find_host_bridge(bus);
 466         struct tegra_pcie *pcie = pci_host_bridge_priv(host);
 467         struct device *dev = pcie->dev;
 468         void __iomem *addr = NULL;
 469
 470         if (bus->number == 0) {
 471                 unsigned int slot = PCI_SLOT(devfn);
 472                 struct tegra_pcie_port *port;
 473
 474                 list_for_each_entry(port, &pcie->ports, list) {
 475                         if (port->index + 1 == slot) {
 476                                 addr = port->base + (where & ~3);
 477                                 break;
 478                         }
 479                 }
 480         } else {
 481                 struct tegra_pcie_bus *b;
 482
 483                 list_for_each_entry(b, &pcie->buses, list)
 484                         if (b->nr == bus->number)
 485                                 addr = (void __iomem *)b->area->addr;
 486
 487                 if (!addr) {
 488                         dev_err(dev, "failed to map cfg. space for bus %u\n",
 489                                 bus->number);
 490                         return NULL;
 491                 }
 492
 493                 addr += tegra_pcie_conf_offset(devfn, where);
 494         }
 495
 496         return addr;
 497 }
 498
 499 static struct pci_ops tegra_pcie_ops = {
 500         .add_bus = tegra_pcie_add_bus,
 501         .remove_bus = tegra_pcie_remove_bus,
 502         .map_bus = tegra_pcie_map_bus,
 503         .read = pci_generic_config_read32,
 504         .write = pci_generic_config_write32,
 505 };
 506
 507 static unsigned long tegra_pcie_port_get_pex_ctrl(struct tegra_pcie_port *port)
 508 {
 509         unsigned long ret = 0;
 510
 511         switch (port->index) {
 512         case 0:
 513                 ret = AFI_PEX0_CTRL;
 514                 break;
 515
 516         case 1:
 517                 ret = AFI_PEX1_CTRL;
 518                 break;
 519
 520         case 2:
 521                 ret = AFI_PEX2_CTRL;
 522                 break;
 523         }
 524
 525         return ret;
 526 }
 527
 528 static void tegra_pcie_port_reset(struct tegra_pcie_port *port)
 529 {
 530         unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
 531         unsigned long value;
 532
 533         /* pulse reset signal */
 534         value = afi_readl(port->pcie, ctrl);
 535         value &= ~AFI_PEX_CTRL_RST;
 536         afi_writel(port->pcie, value, ctrl);
 537
 538         usleep_range(1000, 2000);
 539
 540         value = afi_readl(port->pcie, ctrl);
 541         value |= AFI_PEX_CTRL_RST;
 542         afi_writel(port->pcie, value, ctrl);
 543 }
 544
 545 static void tegra_pcie_port_enable(struct tegra_pcie_port *port)
 546 {
 547         unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
 548         const struct tegra_pcie_soc *soc = port->pcie->soc;
 549         unsigned long value;
 550
 551         /* enable reference clock */
 552         value = afi_readl(port->pcie, ctrl);
 553         value |= AFI_PEX_CTRL_REFCLK_EN;
 554
 555         if (soc->has_pex_clkreq_en)
 556                 value |= AFI_PEX_CTRL_CLKREQ_EN;
 557
 558         value |= AFI_PEX_CTRL_OVERRIDE_EN;
 559
 560         afi_writel(port->pcie, value, ctrl);
 561
 562         tegra_pcie_port_reset(port);
 563
 564         if (soc->force_pca_enable) {
 565                 value = readl(port->base + RP_VEND_CTL2);
 566                 value |= RP_VEND_CTL2_PCA_ENABLE;
 567                 writel(value, port->base + RP_VEND_CTL2);
 568         }
 569 }
 570
 571 static void tegra_pcie_port_disable(struct tegra_pcie_port *port)
 572 {
 573         unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
 574         const struct tegra_pcie_soc *soc = port->pcie->soc;
 575         unsigned long value;
 576
 577         /* assert port reset */
 578         value = afi_readl(port->pcie, ctrl);
 579         value &= ~AFI_PEX_CTRL_RST;
 580         afi_writel(port->pcie, value, ctrl);
 581
 582         /* disable reference clock */
 583         value = afi_readl(port->pcie, ctrl);
 584
 585         if (soc->has_pex_clkreq_en)
 586                 value &= ~AFI_PEX_CTRL_CLKREQ_EN;
 587
 588         value &= ~AFI_PEX_CTRL_REFCLK_EN;
 589         afi_writel(port->pcie, value, ctrl);
 590 }
 591
 592 static void tegra_pcie_port_free(struct tegra_pcie_port *port)
 593 {
 594         struct tegra_pcie *pcie = port->pcie;
 595         struct device *dev = pcie->dev;
 596
 597         devm_iounmap(dev, port->base);
 598         devm_release_mem_region(dev, port->regs.start,
 599                                 resource_size(&port->regs));
 600         list_del(&port->list);
 601         devm_kfree(dev, port);
 602 }
 603
 604 /* Tegra PCIE root complex wrongly reports device class */
 605 static void tegra_pcie_fixup_class(struct pci_dev *dev)
 606 {
 607         dev->class = PCI_CLASS_BRIDGE_PCI << 8;
 608 }
 609 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0bf0, tegra_pcie_fixup_class);
 610 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0bf1, tegra_pcie_fixup_class);
 611 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0e1c, tegra_pcie_fixup_class);
 612 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0e1d, tegra_pcie_fixup_class);
 613
 614 /* Tegra PCIE requires relaxed ordering */
 615 static void tegra_pcie_relax_enable(struct pci_dev *dev)
 616 {
 617         pcie_capability_set_word(dev, PCI_EXP_DEVCTL, PCI_EXP_DEVCTL_RELAX_EN);
 618 }
 619 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, tegra_pcie_relax_enable);
 620
 621 static int tegra_pcie_request_resources(struct tegra_pcie *pcie)
 622 {
 623         struct pci_host_bridge *host = pci_host_bridge_from_priv(pcie);
 624         struct list_head *windows = &host->windows;
 625         struct device *dev = pcie->dev;
 626         int err;
 627
 628         pci_add_resource_offset(windows, &pcie->pio, pcie->offset.io);
 629         pci_add_resource_offset(windows, &pcie->mem, pcie->offset.mem);
 630         pci_add_resource_offset(windows, &pcie->prefetch, pcie->offset.mem);
 631         pci_add_resource(windows, &pcie->busn);
 632
 633         err = devm_request_pci_bus_resources(dev, windows);
 634         if (err < 0)
 635                 return err;
 636
 637         pci_remap_iospace(&pcie->pio, pcie->io.start);
 638
 639         return 0;
 640 }
 641
 642 static int tegra_pcie_map_irq(const struct pci_dev *pdev, u8 slot, u8 pin)
 643 {
 644         struct pci_host_bridge *host = pci_find_host_bridge(pdev->bus);
 645         struct tegra_pcie *pcie = pci_host_bridge_priv(host);
 646         int irq;
 647
 648         tegra_cpuidle_pcie_irqs_in_use();
 649
 650         irq = of_irq_parse_and_map_pci(pdev, slot, pin);
 651         if (!irq)
 652                 irq = pcie->irq;
 653
 654         return irq;
 655 }
 656
 657 static irqreturn_t tegra_pcie_isr(int irq, void *arg)
 658 {
 659         const char *err_msg[] = {
 660                 "Unknown",
 661                 "AXI slave error",
 662                 "AXI decode error",
 663                 "Target abort",
 664                 "Master abort",
 665                 "Invalid write",
 666                 "Legacy interrupt",
 667                 "Response decoding error",
 668                 "AXI response decoding error",
 669                 "Transaction timeout",
 670                 "Slot present pin change",
 671                 "Slot clock request change",
 672                 "TMS clock ramp change",
 673                 "TMS ready for power down",
 674                 "Peer2Peer error",
 675         };
 676         struct tegra_pcie *pcie = arg;
 677         struct device *dev = pcie->dev;
 678         u32 code, signature;
 679
 680         code = afi_readl(pcie, AFI_INTR_CODE) & AFI_INTR_CODE_MASK;
 681         signature = afi_readl(pcie, AFI_INTR_SIGNATURE);
 682         afi_writel(pcie, 0, AFI_INTR_CODE);
 683
 684         if (code == AFI_INTR_LEGACY)
 685                 return IRQ_NONE;
 686
 687         if (code >= ARRAY_SIZE(err_msg))
 688                 code = 0;
 689
 690         /*
 691          * do not pollute kernel log with master abort reports since they
 692          * happen a lot during enumeration
 693          */
 694         if (code == AFI_INTR_MASTER_ABORT)
 695                 dev_dbg(dev, "%s, signature: %08x\n", err_msg[code], signature);
 696         else
 697                 dev_err(dev, "%s, signature: %08x\n", err_msg[code], signature);
 698
 699         if (code == AFI_INTR_TARGET_ABORT || code == AFI_INTR_MASTER_ABORT ||
 700             code == AFI_INTR_FPCI_DECODE_ERROR) {
 701                 u32 fpci = afi_readl(pcie, AFI_UPPER_FPCI_ADDRESS) & 0xff;
 702                 u64 address = (u64)fpci << 32 | (signature & 0xfffffffc);
 703
 704                 if (code == AFI_INTR_MASTER_ABORT)
 705                         dev_dbg(dev, "  FPCI address: %10llx\n", address);
 706                 else
 707                         dev_err(dev, "  FPCI address: %10llx\n", address);
 708         }
 709
 710         return IRQ_HANDLED;
 711 }
 712
 713 /*
 714  * FPCI map is as follows:
 715  * - 0xfdfc000000: I/O space
 716  * - 0xfdfe000000: type 0 configuration space
 717  * - 0xfdff000000: type 1 configuration space
 718  * - 0xfe00000000: type 0 extended configuration space
 719  * - 0xfe10000000: type 1 extended configuration space
 720  */
 721 static void tegra_pcie_setup_translations(struct tegra_pcie *pcie)
 722 {
 723         u32 fpci_bar, size, axi_address;
 724
 725         /* Bar 0: type 1 extended configuration space */
 726         fpci_bar = 0xfe100000;
 727         size = resource_size(pcie->cs);
 728         axi_address = pcie->cs->start;
 729         afi_writel(pcie, axi_address, AFI_AXI_BAR0_START);
 730         afi_writel(pcie, size >> 12, AFI_AXI_BAR0_SZ);
 731         afi_writel(pcie, fpci_bar, AFI_FPCI_BAR0);
 732
 733         /* Bar 1: downstream IO bar */
 734         fpci_bar = 0xfdfc0000;
 735         size = resource_size(&pcie->io);
 736         axi_address = pcie->io.start;
 737         afi_writel(pcie, axi_address, AFI_AXI_BAR1_START);
 738         afi_writel(pcie, size >> 12, AFI_AXI_BAR1_SZ);
 739         afi_writel(pcie, fpci_bar, AFI_FPCI_BAR1);
 740
 741         /* Bar 2: prefetchable memory BAR */
 742         fpci_bar = (((pcie->prefetch.start >> 12) & 0x0fffffff) << 4) | 0x1;
 743         size = resource_size(&pcie->prefetch);
 744         axi_address = pcie->prefetch.start;
 745         afi_writel(pcie, axi_address, AFI_AXI_BAR2_START);
 746         afi_writel(pcie, size >> 12, AFI_AXI_BAR2_SZ);
 747         afi_writel(pcie, fpci_bar, AFI_FPCI_BAR2);
 748
 749         /* Bar 3: non prefetchable memory BAR */
 750         fpci_bar = (((pcie->mem.start >> 12) & 0x0fffffff) << 4) | 0x1;
 751         size = resource_size(&pcie->mem);
 752         axi_address = pcie->mem.start;
 753         afi_writel(pcie, axi_address, AFI_AXI_BAR3_START);
 754         afi_writel(pcie, size >> 12, AFI_AXI_BAR3_SZ);
 755         afi_writel(pcie, fpci_bar, AFI_FPCI_BAR3);
 756
 757         /* NULL out the remaining BARs as they are not used */
 758         afi_writel(pcie, 0, AFI_AXI_BAR4_START);
 759         afi_writel(pcie, 0, AFI_AXI_BAR4_SZ);
 760         afi_writel(pcie, 0, AFI_FPCI_BAR4);
 761
 762         afi_writel(pcie, 0, AFI_AXI_BAR5_START);
 763         afi_writel(pcie, 0, AFI_AXI_BAR5_SZ);
 764         afi_writel(pcie, 0, AFI_FPCI_BAR5);
 765
 766         /* map all upstream transactions as uncached */
 767         afi_writel(pcie, 0, AFI_CACHE_BAR0_ST);
 768         afi_writel(pcie, 0, AFI_CACHE_BAR0_SZ);
 769         afi_writel(pcie, 0, AFI_CACHE_BAR1_ST);
 770         afi_writel(pcie, 0, AFI_CACHE_BAR1_SZ);
 771
 772         /* MSI translations are setup only when needed */
 773         afi_writel(pcie, 0, AFI_MSI_FPCI_BAR_ST);
 774         afi_writel(pcie, 0, AFI_MSI_BAR_SZ);
 775         afi_writel(pcie, 0, AFI_MSI_AXI_BAR_ST);
 776         afi_writel(pcie, 0, AFI_MSI_BAR_SZ);
 777 }
 778
 779 static int tegra_pcie_pll_wait(struct tegra_pcie *pcie, unsigned long timeout)
 780 {
 781         const struct tegra_pcie_soc *soc = pcie->soc;
 782         u32 value;
 783
 784         timeout = jiffies + msecs_to_jiffies(timeout);
 785
 786         while (time_before(jiffies, timeout)) {
 787                 value = pads_readl(pcie, soc->pads_pll_ctl);
 788                 if (value & PADS_PLL_CTL_LOCKDET)
 789                         return 0;
 790         }
 791
 792         return -ETIMEDOUT;
 793 }
 794
 795 static int tegra_pcie_phy_enable(struct tegra_pcie *pcie)
 796 {
 797         struct device *dev = pcie->dev;
 798         const struct tegra_pcie_soc *soc = pcie->soc;
 799         u32 value;
 800         int err;
 801
 802         /* initialize internal PHY, enable up to 16 PCIE lanes */
 803         pads_writel(pcie, 0x0, PADS_CTL_SEL);
 804
 805         /* override IDDQ to 1 on all 4 lanes */
 806         value = pads_readl(pcie, PADS_CTL);
 807         value |= PADS_CTL_IDDQ_1L;
 808         pads_writel(pcie, value, PADS_CTL);
 809
 810         /*
 811          * Set up PHY PLL inputs select PLLE output as refclock,
 812          * set TX ref sel to div10 (not div5).
 813          */
 814         value = pads_readl(pcie, soc->pads_pll_ctl);
 815         value &= ~(PADS_PLL_CTL_REFCLK_MASK | PADS_PLL_CTL_TXCLKREF_MASK);
 816         value |= PADS_PLL_CTL_REFCLK_INTERNAL_CML | soc->tx_ref_sel;
 817         pads_writel(pcie, value, soc->pads_pll_ctl);
 818
 819         /* reset PLL */
 820         value = pads_readl(pcie, soc->pads_pll_ctl);
 821         value &= ~PADS_PLL_CTL_RST_B4SM;
 822         pads_writel(pcie, value, soc->pads_pll_ctl);
 823
 824         usleep_range(20, 100);
 825
 826         /* take PLL out of reset  */
 827         value = pads_readl(pcie, soc->pads_pll_ctl);
 828         value |= PADS_PLL_CTL_RST_B4SM;
 829         pads_writel(pcie, value, soc->pads_pll_ctl);
 830
 831         /* wait for the PLL to lock */
 832         err = tegra_pcie_pll_wait(pcie, 500);
 833         if (err < 0) {
 834                 dev_err(dev, "PLL failed to lock: %d\n", err);
 835                 return err;
 836         }
 837
 838         /* turn off IDDQ override */
 839         value = pads_readl(pcie, PADS_CTL);
 840         value &= ~PADS_CTL_IDDQ_1L;
 841         pads_writel(pcie, value, PADS_CTL);
 842
 843         /* enable TX/RX data */
 844         value = pads_readl(pcie, PADS_CTL);
 845         value |= PADS_CTL_TX_DATA_EN_1L | PADS_CTL_RX_DATA_EN_1L;
 846         pads_writel(pcie, value, PADS_CTL);
 847
 848         return 0;
 849 }
 850
 851 static int tegra_pcie_phy_disable(struct tegra_pcie *pcie)
 852 {
 853         const struct tegra_pcie_soc *soc = pcie->soc;
 854         u32 value;
 855
 856         /* disable TX/RX data */
 857         value = pads_readl(pcie, PADS_CTL);
 858         value &= ~(PADS_CTL_TX_DATA_EN_1L | PADS_CTL_RX_DATA_EN_1L);
 859         pads_writel(pcie, value, PADS_CTL);
 860
 861         /* override IDDQ */
 862         value = pads_readl(pcie, PADS_CTL);
 863         value |= PADS_CTL_IDDQ_1L;
 864         pads_writel(pcie, value, PADS_CTL);
 865
 866         /* reset PLL */
 867         value = pads_readl(pcie, soc->pads_pll_ctl);
 868         value &= ~PADS_PLL_CTL_RST_B4SM;
 869         pads_writel(pcie, value, soc->pads_pll_ctl);
 870
 871         usleep_range(20, 100);
 872
 873         return 0;
 874 }
 875
 876 static int tegra_pcie_port_phy_power_on(struct tegra_pcie_port *port)
 877 {
 878         struct device *dev = port->pcie->dev;
 879         unsigned int i;
 880         int err;
 881
 882         for (i = 0; i < port->lanes; i++) {
 883                 err = phy_power_on(port->phys[i]);
 884                 if (err < 0) {
 885                         dev_err(dev, "failed to power on PHY#%u: %d\n", i, err);
 886                         return err;
 887                 }
 888         }
 889
 890         return 0;
 891 }
 892
 893 static int tegra_pcie_port_phy_power_off(struct tegra_pcie_port *port)
 894 {
 895         struct device *dev = port->pcie->dev;
 896         unsigned int i;
 897         int err;
 898
 899         for (i = 0; i < port->lanes; i++) {
 900                 err = phy_power_off(port->phys[i]);
 901                 if (err < 0) {
 902                         dev_err(dev, "failed to power off PHY#%u: %d\n", i,
 903                                 err);
 904                         return err;
 905                 }
 906         }
 907
 908         return 0;
 909 }
 910
 911 static int tegra_pcie_phy_power_on(struct tegra_pcie *pcie)
 912 {
 913         struct device *dev = pcie->dev;
 914         const struct tegra_pcie_soc *soc = pcie->soc;
 915         struct tegra_pcie_port *port;
 916         int err;
 917
 918         if (pcie->legacy_phy) {
 919                 if (pcie->phy)
 920                         err = phy_power_on(pcie->phy);
 921                 else
 922                         err = tegra_pcie_phy_enable(pcie);
 923
 924                 if (err < 0)
 925                         dev_err(dev, "failed to power on PHY: %d\n", err);
 926
 927                 return err;
 928         }
 929
 930         list_for_each_entry(port, &pcie->ports, list) {
 931                 err = tegra_pcie_port_phy_power_on(port);
 932                 if (err < 0) {
 933                         dev_err(dev,
 934                                 "failed to power on PCIe port %u PHY: %d\n",
 935                                 port->index, err);
 936                         return err;
 937                 }
 938         }
 939
 940         /* Configure the reference clock driver */
 941         pads_writel(pcie, soc->pads_refclk_cfg0, PADS_REFCLK_CFG0);
 942
 943         if (soc->num_ports > 2)
 944                 pads_writel(pcie, soc->pads_refclk_cfg1, PADS_REFCLK_CFG1);
 945
 946         return 0;
 947 }
 948
 949 static int tegra_pcie_phy_power_off(struct tegra_pcie *pcie)
 950 {
 951         struct device *dev = pcie->dev;
 952         struct tegra_pcie_port *port;
 953         int err;
 954
 955         if (pcie->legacy_phy) {
 956                 if (pcie->phy)
 957                         err = phy_power_off(pcie->phy);
 958                 else
 959                         err = tegra_pcie_phy_disable(pcie);
 960
 961                 if (err < 0)
 962                         dev_err(dev, "failed to power off PHY: %d\n", err);
 963
 964                 return err;
 965         }
 966
 967         list_for_each_entry(port, &pcie->ports, list) {
 968                 err = tegra_pcie_port_phy_power_off(port);
 969                 if (err < 0) {
 970                         dev_err(dev,
 971                                 "failed to power off PCIe port %u PHY: %d\n",
 972                                 port->index, err);
 973                         return err;
 974                 }
 975         }
 976
 977         return 0;
 978 }
 979
 980 static int tegra_pcie_enable_controller(struct tegra_pcie *pcie)
 981 {
 982         struct device *dev = pcie->dev;
 983         const struct tegra_pcie_soc *soc = pcie->soc;
 984         struct tegra_pcie_port *port;
 985         unsigned long value;
 986         int err;
 987
 988         /* enable PLL power down */
 989         if (pcie->phy) {
 990                 value = afi_readl(pcie, AFI_PLLE_CONTROL);
 991                 value &= ~AFI_PLLE_CONTROL_BYPASS_PADS2PLLE_CONTROL;
 992                 value |= AFI_PLLE_CONTROL_PADS2PLLE_CONTROL_EN;
 993                 afi_writel(pcie, value, AFI_PLLE_CONTROL);
 994         }
 995
 996         /* power down PCIe slot clock bias pad */
 997         if (soc->has_pex_bias_ctrl)
 998                 afi_writel(pcie, 0, AFI_PEXBIAS_CTRL_0);
 999
1000         /* configure mode and disable all ports */
1001         value = afi_readl(pcie, AFI_PCIE_CONFIG);
1002         value &= ~AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_MASK;
1003         value |= AFI_PCIE_CONFIG_PCIE_DISABLE_ALL | pcie->xbar_config;
1004
1005         list_for_each_entry(port, &pcie->ports, list)
1006                 value &= ~AFI_PCIE_CONFIG_PCIE_DISABLE(port->index);
1007
1008         afi_writel(pcie, value, AFI_PCIE_CONFIG);
1009
1010         if (soc->has_gen2) {
1011                 value = afi_readl(pcie, AFI_FUSE);
1012                 value &= ~AFI_FUSE_PCIE_T0_GEN2_DIS;
1013                 afi_writel(pcie, value, AFI_FUSE);
1014         } else {
1015                 value = afi_readl(pcie, AFI_FUSE);
1016                 value |= AFI_FUSE_PCIE_T0_GEN2_DIS;
1017                 afi_writel(pcie, value, AFI_FUSE);
1018         }
1019
1020         err = tegra_pcie_phy_power_on(pcie);
1021         if (err < 0) {
1022                 dev_err(dev, "failed to power on PHY(s): %d\n", err);
1023                 return err;
1024         }
1025
1026         /* take the PCIe interface module out of reset */
1027         reset_control_deassert(pcie->pcie_xrst);
1028
1029         /* finally enable PCIe */
1030         value = afi_readl(pcie, AFI_CONFIGURATION);
1031         value |= AFI_CONFIGURATION_EN_FPCI;
1032         afi_writel(pcie, value, AFI_CONFIGURATION);
1033
1034         value = AFI_INTR_EN_INI_SLVERR | AFI_INTR_EN_INI_DECERR |
1035                 AFI_INTR_EN_TGT_SLVERR | AFI_INTR_EN_TGT_DECERR |
1036                 AFI_INTR_EN_TGT_WRERR | AFI_INTR_EN_DFPCI_DECERR;
1037
1038         if (soc->has_intr_prsnt_sense)
1039                 value |= AFI_INTR_EN_PRSNT_SENSE;
1040
1041         afi_writel(pcie, value, AFI_AFI_INTR_ENABLE);
1042         afi_writel(pcie, 0xffffffff, AFI_SM_INTR_ENABLE);
1043
1044         /* don't enable MSI for now, only when needed */
1045         afi_writel(pcie, AFI_INTR_MASK_INT_MASK, AFI_INTR_MASK);
1046
1047         /* disable all exceptions */
1048         afi_writel(pcie, 0, AFI_FPCI_ERROR_MASKS);
1049
1050         return 0;
1051 }
1052
1053 static void tegra_pcie_power_off(struct tegra_pcie *pcie)
1054 {
1055         struct device *dev = pcie->dev;
1056         int err;
1057
1058         /* TODO: disable and unprepare clocks? */
1059
1060         err = tegra_pcie_phy_power_off(pcie);
1061         if (err < 0)
1062                 dev_err(dev, "failed to power off PHY(s): %d\n", err);
1063
1064         reset_control_assert(pcie->pcie_xrst);
1065         reset_control_assert(pcie->afi_rst);
1066         reset_control_assert(pcie->pex_rst);
1067
1068         tegra_powergate_power_off(TEGRA_POWERGATE_PCIE);
1069
1070         err = regulator_bulk_disable(pcie->num_supplies, pcie->supplies);
1071         if (err < 0)
1072                 dev_warn(dev, "failed to disable regulators: %d\n", err);
1073 }
1074
1075 static int tegra_pcie_power_on(struct tegra_pcie *pcie)
1076 {
1077         struct device *dev = pcie->dev;
1078         const struct tegra_pcie_soc *soc = pcie->soc;
1079         int err;
1080
1081         reset_control_assert(pcie->pcie_xrst);
1082         reset_control_assert(pcie->afi_rst);
1083         reset_control_assert(pcie->pex_rst);
1084
1085         tegra_powergate_power_off(TEGRA_POWERGATE_PCIE);
1086
1087         /* enable regulators */
1088         err = regulator_bulk_enable(pcie->num_supplies, pcie->supplies);
1089         if (err < 0)
1090                 dev_err(dev, "failed to enable regulators: %d\n", err);
1091
1092         err = tegra_powergate_sequence_power_up(TEGRA_POWERGATE_PCIE,
1093                                                 pcie->pex_clk,
1094                                                 pcie->pex_rst);
1095         if (err) {
1096                 dev_err(dev, "powerup sequence failed: %d\n", err);
1097                 return err;
1098         }
1099
1100         reset_control_deassert(pcie->afi_rst);
1101
1102         err = clk_prepare_enable(pcie->afi_clk);
1103         if (err < 0) {
1104                 dev_err(dev, "failed to enable AFI clock: %d\n", err);
1105                 return err;
1106         }
1107
1108         if (soc->has_cml_clk) {
1109                 err = clk_prepare_enable(pcie->cml_clk);
1110                 if (err < 0) {
1111                         dev_err(dev, "failed to enable CML clock: %d\n", err);
1112                         return err;
1113                 }
1114         }
1115
1116         err = clk_prepare_enable(pcie->pll_e);
1117         if (err < 0) {
1118                 dev_err(dev, "failed to enable PLLE clock: %d\n", err);
1119                 return err;
1120         }
1121
1122         return 0;
1123 }
1124
1125 static int tegra_pcie_clocks_get(struct tegra_pcie *pcie)
1126 {
1127         struct device *dev = pcie->dev;
1128         const struct tegra_pcie_soc *soc = pcie->soc;
1129
1130         pcie->pex_clk = devm_clk_get(dev, "pex");
1131         if (IS_ERR(pcie->pex_clk))
1132                 return PTR_ERR(pcie->pex_clk);
1133
1134         pcie->afi_clk = devm_clk_get(dev, "afi");
1135         if (IS_ERR(pcie->afi_clk))
1136                 return PTR_ERR(pcie->afi_clk);
1137
1138         pcie->pll_e = devm_clk_get(dev, "pll_e");
1139         if (IS_ERR(pcie->pll_e))
1140                 return PTR_ERR(pcie->pll_e);
1141
1142         if (soc->has_cml_clk) {
1143                 pcie->cml_clk = devm_clk_get(dev, "cml");
1144                 if (IS_ERR(pcie->cml_clk))
1145                         return PTR_ERR(pcie->cml_clk);
1146         }
1147
1148         return 0;
1149 }
1150
1151 static int tegra_pcie_resets_get(struct tegra_pcie *pcie)
1152 {
1153         struct device *dev = pcie->dev;
1154
1155         pcie->pex_rst = devm_reset_control_get(dev, "pex");
1156         if (IS_ERR(pcie->pex_rst))
1157                 return PTR_ERR(pcie->pex_rst);
1158
1159         pcie->afi_rst = devm_reset_control_get(dev, "afi");
1160         if (IS_ERR(pcie->afi_rst))
1161                 return PTR_ERR(pcie->afi_rst);
1162
1163         pcie->pcie_xrst = devm_reset_control_get(dev, "pcie_x");
1164         if (IS_ERR(pcie->pcie_xrst))
1165                 return PTR_ERR(pcie->pcie_xrst);
1166
1167         return 0;
1168 }
1169
1170 static int tegra_pcie_phys_get_legacy(struct tegra_pcie *pcie)
1171 {
1172         struct device *dev = pcie->dev;
1173         int err;
1174
1175         pcie->phy = devm_phy_optional_get(dev, "pcie");
1176         if (IS_ERR(pcie->phy)) {
1177                 err = PTR_ERR(pcie->phy);
1178                 dev_err(dev, "failed to get PHY: %d\n", err);
1179                 return err;
1180         }
1181
1182         err = phy_init(pcie->phy);
1183         if (err < 0) {
1184                 dev_err(dev, "failed to initialize PHY: %d\n", err);
1185                 return err;
1186         }
1187
1188         pcie->legacy_phy = true;
1189
1190         return 0;
1191 }
1192
1193 static struct phy *devm_of_phy_optional_get_index(struct device *dev,
1194                                                   struct device_node *np,
1195                                                   const char *consumer,
1196                                                   unsigned int index)
1197 {
1198         struct phy *phy;
1199         char *name;
1200
1201         name = kasprintf(GFP_KERNEL, "%s-%u", consumer, index);
1202         if (!name)
1203                 return ERR_PTR(-ENOMEM);
1204
1205         phy = devm_of_phy_get(dev, np, name);
1206         kfree(name);
1207
1208         if (IS_ERR(phy) && PTR_ERR(phy) == -ENODEV)
1209                 phy = NULL;
1210
1211         return phy;
1212 }
1213
1214 static int tegra_pcie_port_get_phys(struct tegra_pcie_port *port)
1215 {
1216         struct device *dev = port->pcie->dev;
1217         struct phy *phy;
1218         unsigned int i;
1219         int err;
1220
1221         port->phys = devm_kcalloc(dev, sizeof(phy), port->lanes, GFP_KERNEL);
1222         if (!port->phys)
1223                 return -ENOMEM;
1224
1225         for (i = 0; i < port->lanes; i++) {
1226                 phy = devm_of_phy_optional_get_index(dev, port->np, "pcie", i);
1227                 if (IS_ERR(phy)) {
1228                         dev_err(dev, "failed to get PHY#%u: %ld\n", i,
1229                                 PTR_ERR(phy));
1230                         return PTR_ERR(phy);
1231                 }
1232
1233                 err = phy_init(phy);
1234                 if (err < 0) {
1235                         dev_err(dev, "failed to initialize PHY#%u: %d\n", i,
1236                                 err);
1237                         return err;
1238                 }
1239
1240                 port->phys[i] = phy;
1241         }
1242
1243         return 0;
1244 }
1245
1246 static int tegra_pcie_phys_get(struct tegra_pcie *pcie)
1247 {
1248         const struct tegra_pcie_soc *soc = pcie->soc;
1249         struct device_node *np = pcie->dev->of_node;
1250         struct tegra_pcie_port *port;
1251         int err;
1252
1253         if (!soc->has_gen2 || of_find_property(np, "phys", NULL) != NULL)
1254                 return tegra_pcie_phys_get_legacy(pcie);
1255
1256         list_for_each_entry(port, &pcie->ports, list) {
1257                 err = tegra_pcie_port_get_phys(port);
1258                 if (err < 0)
1259                         return err;
1260         }
1261
1262         return 0;
1263 }
1264
1265 static int tegra_pcie_get_resources(struct tegra_pcie *pcie)
1266 {
1267         struct device *dev = pcie->dev;
1268         struct platform_device *pdev = to_platform_device(dev);
1269         struct resource *pads, *afi, *res;
1270         int err;
1271
1272         err = tegra_pcie_clocks_get(pcie);
1273         if (err) {
1274                 dev_err(dev, "failed to get clocks: %d\n", err);
1275                 return err;
1276         }
1277
1278         err = tegra_pcie_resets_get(pcie);
1279         if (err) {
1280                 dev_err(dev, "failed to get resets: %d\n", err);
1281                 return err;
1282         }
1283
1284         err = tegra_pcie_phys_get(pcie);
1285         if (err < 0) {
1286                 dev_err(dev, "failed to get PHYs: %d\n", err);
1287                 return err;
1288         }
1289
1290         err = tegra_pcie_power_on(pcie);
1291         if (err) {
1292                 dev_err(dev, "failed to power up: %d\n", err);
1293                 return err;
1294         }
1295
1296         pads = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pads");
1297         pcie->pads = devm_ioremap_resource(dev, pads);
1298         if (IS_ERR(pcie->pads)) {
1299                 err = PTR_ERR(pcie->pads);
1300                 goto poweroff;
1301         }
1302
1303         afi = platform_get_resource_byname(pdev, IORESOURCE_MEM, "afi");
1304         pcie->afi = devm_ioremap_resource(dev, afi);
1305         if (IS_ERR(pcie->afi)) {
1306                 err = PTR_ERR(pcie->afi);
1307                 goto poweroff;
1308         }
1309
1310         /* request configuration space, but remap later, on demand */
1311         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cs");
1312         if (!res) {
1313                 err = -EADDRNOTAVAIL;
1314                 goto poweroff;
1315         }
1316
1317         pcie->cs = devm_request_mem_region(dev, res->start,
1318                                            resource_size(res), res->name);
1319         if (!pcie->cs) {
1320                 err = -EADDRNOTAVAIL;
1321                 goto poweroff;
1322         }
1323
1324         /* request interrupt */
1325         err = platform_get_irq_byname(pdev, "intr");
1326         if (err < 0) {
1327                 dev_err(dev, "failed to get IRQ: %d\n", err);
1328                 goto poweroff;
1329         }
1330
1331         pcie->irq = err;
1332
1333         err = request_irq(pcie->irq, tegra_pcie_isr, IRQF_SHARED, "PCIE", pcie);
1334         if (err) {
1335                 dev_err(dev, "failed to register IRQ: %d\n", err);
1336                 goto poweroff;
1337         }
1338
1339         return 0;
1340
1341 poweroff:
1342         tegra_pcie_power_off(pcie);
1343         return err;
1344 }
1345
1346 static int tegra_pcie_put_resources(struct tegra_pcie *pcie)
1347 {
1348         struct device *dev = pcie->dev;
1349         int err;
1350
1351         if (pcie->irq > 0)
1352                 free_irq(pcie->irq, pcie);
1353
1354         tegra_pcie_power_off(pcie);
1355
1356         err = phy_exit(pcie->phy);
1357         if (err < 0)
1358                 dev_err(dev, "failed to teardown PHY: %d\n", err);
1359
1360         return 0;
1361 }
1362
1363 static int tegra_msi_alloc(struct tegra_msi *chip)
1364 {
1365         int msi;
1366
1367         mutex_lock(&chip->lock);
1368
1369         msi = find_first_zero_bit(chip->used, INT_PCI_MSI_NR);
1370         if (msi < INT_PCI_MSI_NR)
1371                 set_bit(msi, chip->used);
1372         else
1373                 msi = -ENOSPC;
1374
1375         mutex_unlock(&chip->lock);
1376
1377         return msi;
1378 }
1379
1380 static void tegra_msi_free(struct tegra_msi *chip, unsigned long irq)
1381 {
1382         struct device *dev = chip->chip.dev;
1383
1384         mutex_lock(&chip->lock);
1385
1386         if (!test_bit(irq, chip->used))
1387                 dev_err(dev, "trying to free unused MSI#%lu\n", irq);
1388         else
1389                 clear_bit(irq, chip->used);
1390
1391         mutex_unlock(&chip->lock);
1392 }
1393
1394 static irqreturn_t tegra_pcie_msi_irq(int irq, void *data)
1395 {
1396         struct tegra_pcie *pcie = data;
1397         struct device *dev = pcie->dev;
1398         struct tegra_msi *msi = &pcie->msi;
1399         unsigned int i, processed = 0;
1400
1401         for (i = 0; i < 8; i++) {
1402                 unsigned long reg = afi_readl(pcie, AFI_MSI_VEC0 + i * 4);
1403
1404                 while (reg) {
1405                         unsigned int offset = find_first_bit(&reg, 32);
1406                         unsigned int index = i * 32 + offset;
1407                         unsigned int irq;
1408
1409                         /* clear the interrupt */
1410                         afi_writel(pcie, 1 << offset, AFI_MSI_VEC0 + i * 4);
1411
1412                         irq = irq_find_mapping(msi->domain, index);
1413                         if (irq) {
1414                                 if (test_bit(index, msi->used))
1415                                         generic_handle_irq(irq);
1416                                 else
1417                                         dev_info(dev, "unhandled MSI\n");
1418                         } else {
1419                                 /*
1420                                  * that's weird who triggered this?
1421                                  * just clear it
1422                                  */
1423                                 dev_info(dev, "unexpected MSI\n");
1424                         }
1425
1426                         /* see if there's any more pending in this vector */
1427                         reg = afi_readl(pcie, AFI_MSI_VEC0 + i * 4);
1428
1429                         processed++;
1430                 }
1431         }
1432
1433         return processed > 0 ? IRQ_HANDLED : IRQ_NONE;
1434 }
1435
1436 static int tegra_msi_setup_irq(struct msi_controller *chip,
1437                                struct pci_dev *pdev, struct msi_desc *desc)
1438 {
1439         struct tegra_msi *msi = to_tegra_msi(chip);
1440         struct msi_msg msg;
1441         unsigned int irq;
1442         int hwirq;
1443
1444         hwirq = tegra_msi_alloc(msi);
1445         if (hwirq < 0)
1446                 return hwirq;
1447
1448         irq = irq_create_mapping(msi->domain, hwirq);
1449         if (!irq) {
1450                 tegra_msi_free(msi, hwirq);
1451                 return -EINVAL;
1452         }
1453
1454         irq_set_msi_desc(irq, desc);
1455
1456         msg.address_lo = virt_to_phys((void *)msi->pages);
1457         /* 32 bit address only */
1458         msg.address_hi = 0;
1459         msg.data = hwirq;
1460
1461         pci_write_msi_msg(irq, &msg);
1462
1463         return 0;
1464 }
1465
1466 static void tegra_msi_teardown_irq(struct msi_controller *chip,
1467                                    unsigned int irq)
1468 {
1469         struct tegra_msi *msi = to_tegra_msi(chip);
1470         struct irq_data *d = irq_get_irq_data(irq);
1471         irq_hw_number_t hwirq = irqd_to_hwirq(d);
1472
1473         irq_dispose_mapping(irq);
1474         tegra_msi_free(msi, hwirq);
1475 }
1476
1477 static struct irq_chip tegra_msi_irq_chip = {
1478         .name = "Tegra PCIe MSI",
1479         .irq_enable = pci_msi_unmask_irq,
1480         .irq_disable = pci_msi_mask_irq,
1481         .irq_mask = pci_msi_mask_irq,
1482         .irq_unmask = pci_msi_unmask_irq,
1483 };
1484
1485 static int tegra_msi_map(struct irq_domain *domain, unsigned int irq,
1486                          irq_hw_number_t hwirq)
1487 {
1488         irq_set_chip_and_handler(irq, &tegra_msi_irq_chip, handle_simple_irq);
1489         irq_set_chip_data(irq, domain->host_data);
1490
1491         tegra_cpuidle_pcie_irqs_in_use();
1492
1493         return 0;
1494 }
1495
1496 static const struct irq_domain_ops msi_domain_ops = {
1497         .map = tegra_msi_map,
1498 };
1499
1500 static int tegra_pcie_enable_msi(struct tegra_pcie *pcie)
1501 {
1502         struct pci_host_bridge *host = pci_host_bridge_from_priv(pcie);
1503         struct platform_device *pdev = to_platform_device(pcie->dev);
1504         const struct tegra_pcie_soc *soc = pcie->soc;
1505         struct tegra_msi *msi = &pcie->msi;
1506         struct device *dev = pcie->dev;
1507         unsigned long base;
1508         int err;
1509         u32 reg;
1510
1511         mutex_init(&msi->lock);
1512
1513         msi->chip.dev = dev;
1514         msi->chip.setup_irq = tegra_msi_setup_irq;
1515         msi->chip.teardown_irq = tegra_msi_teardown_irq;
1516
1517         msi->domain = irq_domain_add_linear(dev->of_node, INT_PCI_MSI_NR,
1518                                             &msi_domain_ops, &msi->chip);
1519         if (!msi->domain) {
1520                 dev_err(dev, "failed to create IRQ domain\n");
1521                 return -ENOMEM;
1522         }
1523
1524         err = platform_get_irq_byname(pdev, "msi");
1525         if (err < 0) {
1526                 dev_err(dev, "failed to get IRQ: %d\n", err);
1527                 goto err;
1528         }
1529
1530         msi->irq = err;
1531
1532         err = request_irq(msi->irq, tegra_pcie_msi_irq, IRQF_NO_THREAD,
1533                           tegra_msi_irq_chip.name, pcie);
1534         if (err < 0) {
1535                 dev_err(dev, "failed to request IRQ: %d\n", err);
1536                 goto err;
1537         }
1538
1539         /* setup AFI/FPCI range */
1540         msi->pages = __get_free_pages(GFP_KERNEL, 0);
1541         base = virt_to_phys((void *)msi->pages);
1542
1543         afi_writel(pcie, base >> soc->msi_base_shift, AFI_MSI_FPCI_BAR_ST);
1544         afi_writel(pcie, base, AFI_MSI_AXI_BAR_ST);
1545         /* this register is in 4K increments */
1546         afi_writel(pcie, 1, AFI_MSI_BAR_SZ);
1547
1548         /* enable all MSI vectors */
1549         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC0);
1550         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC1);
1551         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC2);
1552         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC3);
1553         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC4);
1554         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC5);
1555         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC6);
1556         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC7);
1557
1558         /* and unmask the MSI interrupt */
1559         reg = afi_readl(pcie, AFI_INTR_MASK);
1560         reg |= AFI_INTR_MASK_MSI_MASK;
1561         afi_writel(pcie, reg, AFI_INTR_MASK);
1562
1563         host->msi = &msi->chip;
1564
1565         return 0;
1566
1567 err:
1568         irq_domain_remove(msi->domain);
1569         return err;
1570 }
1571
1572 static int tegra_pcie_disable_msi(struct tegra_pcie *pcie)
1573 {
1574         struct tegra_msi *msi = &pcie->msi;
1575         unsigned int i, irq;
1576         u32 value;
1577
1578         /* mask the MSI interrupt */
1579         value = afi_readl(pcie, AFI_INTR_MASK);
1580         value &= ~AFI_INTR_MASK_MSI_MASK;
1581         afi_writel(pcie, value, AFI_INTR_MASK);
1582
1583         /* disable all MSI vectors */
1584         afi_writel(pcie, 0, AFI_MSI_EN_VEC0);
1585         afi_writel(pcie, 0, AFI_MSI_EN_VEC1);
1586         afi_writel(pcie, 0, AFI_MSI_EN_VEC2);
1587         afi_writel(pcie, 0, AFI_MSI_EN_VEC3);
1588         afi_writel(pcie, 0, AFI_MSI_EN_VEC4);
1589         afi_writel(pcie, 0, AFI_MSI_EN_VEC5);
1590         afi_writel(pcie, 0, AFI_MSI_EN_VEC6);
1591         afi_writel(pcie, 0, AFI_MSI_EN_VEC7);
1592
1593         free_pages(msi->pages, 0);
1594
1595         if (msi->irq > 0)
1596                 free_irq(msi->irq, pcie);
1597
1598         for (i = 0; i < INT_PCI_MSI_NR; i++) {
1599                 irq = irq_find_mapping(msi->domain, i);
1600                 if (irq > 0)
1601                         irq_dispose_mapping(irq);
1602         }
1603
1604         irq_domain_remove(msi->domain);
1605
1606         return 0;
1607 }
1608
1609 static int tegra_pcie_get_xbar_config(struct tegra_pcie *pcie, u32 lanes,
1610                                       u32 *xbar)
1611 {
1612         struct device *dev = pcie->dev;
1613         struct device_node *np = dev->of_node;
1614
1615         if (of_device_is_compatible(np, "nvidia,tegra124-pcie")) {
1616                 switch (lanes) {
1617                 case 0x0000104:
1618                         dev_info(dev, "4x1, 1x1 configuration\n");
1619                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_X4_X1;
1620                         return 0;
1621
1622                 case 0x0000102:
1623                         dev_info(dev, "2x1, 1x1 configuration\n");
1624                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_X2_X1;
1625                         return 0;
1626                 }
1627         } else if (of_device_is_compatible(np, "nvidia,tegra30-pcie")) {
1628                 switch (lanes) {
1629                 case 0x00000204:
1630                         dev_info(dev, "4x1, 2x1 configuration\n");
1631                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_420;
1632                         return 0;
1633
1634                 case 0x00020202:
1635                         dev_info(dev, "2x3 configuration\n");
1636                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_222;
1637                         return 0;
1638
1639                 case 0x00010104:
1640                         dev_info(dev, "4x1, 1x2 configuration\n");
1641                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_411;
1642                         return 0;
1643                 }
1644         } else if (of_device_is_compatible(np, "nvidia,tegra20-pcie")) {
1645                 switch (lanes) {
1646                 case 0x00000004:
1647                         dev_info(dev, "single-mode configuration\n");
1648                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_SINGLE;
1649                         return 0;
1650
1651                 case 0x00000202:
1652                         dev_info(dev, "dual-mode configuration\n");
1653                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_DUAL;
1654                         return 0;
1655                 }
1656         }
1657
1658         return -EINVAL;
1659 }
1660
1661 /*
1662  * Check whether a given set of supplies is available in a device tree node.
1663  * This is used to check whether the new or the legacy device tree bindings
1664  * should be used.
1665  */
1666 static bool of_regulator_bulk_available(struct device_node *np,
1667                                         struct regulator_bulk_data *supplies,
1668                                         unsigned int num_supplies)
1669 {
1670         char property[32];
1671         unsigned int i;
1672
1673         for (i = 0; i < num_supplies; i++) {
1674                 snprintf(property, 32, "%s-supply", supplies[i].supply);
1675
1676                 if (of_find_property(np, property, NULL) == NULL)
1677                         return false;
1678         }
1679
1680         return true;
1681 }
1682
1683 /*
1684  * Old versions of the device tree binding for this device used a set of power
1685  * supplies that didn't match the hardware inputs. This happened to work for a
1686  * number of cases but is not future proof. However to preserve backwards-
1687  * compatibility with old device trees, this function will try to use the old
1688  * set of supplies.
1689  */
1690 static int tegra_pcie_get_legacy_regulators(struct tegra_pcie *pcie)
1691 {
1692         struct device *dev = pcie->dev;
1693         struct device_node *np = dev->of_node;
1694
1695         if (of_device_is_compatible(np, "nvidia,tegra30-pcie"))
1696                 pcie->num_supplies = 3;
1697         else if (of_device_is_compatible(np, "nvidia,tegra20-pcie"))
1698                 pcie->num_supplies = 2;
1699
1700         if (pcie->num_supplies == 0) {
1701                 dev_err(dev, "device %s not supported in legacy mode\n",
1702                         np->full_name);
1703                 return -ENODEV;
1704         }
1705
1706         pcie->supplies = devm_kcalloc(dev, pcie->num_supplies,
1707                                       sizeof(*pcie->supplies),
1708                                       GFP_KERNEL);
1709         if (!pcie->supplies)
1710                 return -ENOMEM;
1711
1712         pcie->supplies[0].supply = "pex-clk";
1713         pcie->supplies[1].supply = "vdd";
1714
1715         if (pcie->num_supplies > 2)
1716                 pcie->supplies[2].supply = "avdd";
1717
1718         return devm_regulator_bulk_get(dev, pcie->num_supplies, pcie->supplies);
1719 }
1720
1721 /*
1722  * Obtains the list of regulators required for a particular generation of the
1723  * IP block.
1724  *
1725  * This would've been nice to do simply by providing static tables for use
1726  * with the regulator_bulk_*() API, but unfortunately Tegra30 is a bit quirky
1727  * in that it has two pairs or AVDD_PEX and VDD_PEX supplies (PEXA and PEXB)
1728  * and either seems to be optional depending on which ports are being used.
1729  */
1730 static int tegra_pcie_get_regulators(struct tegra_pcie *pcie, u32 lane_mask)
1731 {
1732         struct device *dev = pcie->dev;
1733         struct device_node *np = dev->of_node;
1734         unsigned int i = 0;
1735
1736         if (of_device_is_compatible(np, "nvidia,tegra124-pcie")) {
1737                 pcie->num_supplies = 7;
1738
1739                 pcie->supplies = devm_kcalloc(dev, pcie->num_supplies,
1740                                               sizeof(*pcie->supplies),
1741                                               GFP_KERNEL);
1742                 if (!pcie->supplies)
1743                         return -ENOMEM;
1744
1745                 pcie->supplies[i++].supply = "avddio-pex";
1746                 pcie->supplies[i++].supply = "dvddio-pex";
1747                 pcie->supplies[i++].supply = "avdd-pex-pll";
1748                 pcie->supplies[i++].supply = "hvdd-pex";
1749                 pcie->supplies[i++].supply = "hvdd-pex-pll-e";
1750                 pcie->supplies[i++].supply = "vddio-pex-ctl";
1751                 pcie->supplies[i++].supply = "avdd-pll-erefe";
1752         } else if (of_device_is_compatible(np, "nvidia,tegra30-pcie")) {
1753                 bool need_pexa = false, need_pexb = false;
1754
1755                 /* VDD_PEXA and AVDD_PEXA supply lanes 0 to 3 */
1756                 if (lane_mask & 0x0f)
1757                         need_pexa = true;
1758
1759                 /* VDD_PEXB and AVDD_PEXB supply lanes 4 to 5 */
1760                 if (lane_mask & 0x30)
1761                         need_pexb = true;
1762
1763                 pcie->num_supplies = 4 + (need_pexa ? 2 : 0) +
1764                                          (need_pexb ? 2 : 0);
1765
1766                 pcie->supplies = devm_kcalloc(dev, pcie->num_supplies,
1767                                               sizeof(*pcie->supplies),
1768                                               GFP_KERNEL);
1769                 if (!pcie->supplies)
1770                         return -ENOMEM;
1771
1772                 pcie->supplies[i++].supply = "avdd-pex-pll";
1773                 pcie->supplies[i++].supply = "hvdd-pex";
1774                 pcie->supplies[i++].supply = "vddio-pex-ctl";
1775                 pcie->supplies[i++].supply = "avdd-plle";
1776
1777                 if (need_pexa) {
1778                         pcie->supplies[i++].supply = "avdd-pexa";
1779                         pcie->supplies[i++].supply = "vdd-pexa";
1780                 }
1781
1782                 if (need_pexb) {
1783                         pcie->supplies[i++].supply = "avdd-pexb";
1784                         pcie->supplies[i++].supply = "vdd-pexb";
1785                 }
1786         } else if (of_device_is_compatible(np, "nvidia,tegra20-pcie")) {
1787                 pcie->num_supplies = 5;
1788
1789                 pcie->supplies = devm_kcalloc(dev, pcie->num_supplies,
1790                                               sizeof(*pcie->supplies),
1791                                               GFP_KERNEL);
1792                 if (!pcie->supplies)
1793                         return -ENOMEM;
1794
1795                 pcie->supplies[0].supply = "avdd-pex";
1796                 pcie->supplies[1].supply = "vdd-pex";
1797                 pcie->supplies[2].supply = "avdd-pex-pll";
1798                 pcie->supplies[3].supply = "avdd-plle";
1799                 pcie->supplies[4].supply = "vddio-pex-clk";
1800         }
1801
1802         if (of_regulator_bulk_available(dev->of_node, pcie->supplies,
1803                                         pcie->num_supplies))
1804                 return devm_regulator_bulk_get(dev, pcie->num_supplies,
1805                                                pcie->supplies);
1806
1807         /*
1808          * If not all regulators are available for this new scheme, assume
1809          * that the device tree complies with an older version of the device
1810          * tree binding.
1811          */
1812         dev_info(dev, "using legacy DT binding for power supplies\n");
1813
1814         devm_kfree(dev, pcie->supplies);
1815         pcie->num_supplies = 0;
1816
1817         return tegra_pcie_get_legacy_regulators(pcie);
1818 }
1819
1820 static int tegra_pcie_parse_dt(struct tegra_pcie *pcie)
1821 {
1822         struct device *dev = pcie->dev;
1823         struct device_node *np = dev->of_node, *port;
1824         const struct tegra_pcie_soc *soc = pcie->soc;
1825         struct of_pci_range_parser parser;
1826         struct of_pci_range range;
1827         u32 lanes = 0, mask = 0;
1828         unsigned int lane = 0;
1829         struct resource res;
1830         int err;
1831
1832         if (of_pci_range_parser_init(&parser, np)) {
1833                 dev_err(dev, "missing \"ranges\" property\n");
1834                 return -EINVAL;
1835         }
1836
1837         for_each_of_pci_range(&parser, &range) {
1838                 err = of_pci_range_to_resource(&range, np, &res);
1839                 if (err < 0)
1840                         return err;
1841
1842                 switch (res.flags & IORESOURCE_TYPE_BITS) {
1843                 case IORESOURCE_IO:
1844                         /* Track the bus -> CPU I/O mapping offset. */
1845                         pcie->offset.io = res.start - range.pci_addr;
1846
1847                         memcpy(&pcie->pio, &res, sizeof(res));
1848                         pcie->pio.name = np->full_name;
1849
1850                         /*
1851                          * The Tegra PCIe host bridge uses this to program the
1852                          * mapping of the I/O space to the physical address,
1853                          * so we override the .start and .end fields here that
1854                          * of_pci_range_to_resource() converted to I/O space.
1855                          * We also set the IORESOURCE_MEM type to clarify that
1856                          * the resource is in the physical memory space.
1857                          */
1858                         pcie->io.start = range.cpu_addr;
1859                         pcie->io.end = range.cpu_addr + range.size - 1;
1860                         pcie->io.flags = IORESOURCE_MEM;
1861                         pcie->io.name = "I/O";
1862
1863                         memcpy(&res, &pcie->io, sizeof(res));
1864                         break;
1865
1866                 case IORESOURCE_MEM:
1867                         /*
1868                          * Track the bus -> CPU memory mapping offset. This
1869                          * assumes that the prefetchable and non-prefetchable
1870                          * regions will be the last of type IORESOURCE_MEM in
1871                          * the ranges property.
1872                          * */
1873                         pcie->offset.mem = res.start - range.pci_addr;
1874
1875                         if (res.flags & IORESOURCE_PREFETCH) {
1876                                 memcpy(&pcie->prefetch, &res, sizeof(res));
1877                                 pcie->prefetch.name = "prefetchable";
1878                         } else {
1879                                 memcpy(&pcie->mem, &res, sizeof(res));
1880                                 pcie->mem.name = "non-prefetchable";
1881                         }
1882                         break;
1883                 }
1884         }
1885
1886         err = of_pci_parse_bus_range(np, &pcie->busn);
1887         if (err < 0) {
1888                 dev_err(dev, "failed to parse ranges property: %d\n", err);
1889                 pcie->busn.name = np->name;
1890                 pcie->busn.start = 0;
1891                 pcie->busn.end = 0xff;
1892                 pcie->busn.flags = IORESOURCE_BUS;
1893         }
1894
1895         /* parse root ports */
1896         for_each_child_of_node(np, port) {
1897                 struct tegra_pcie_port *rp;
1898                 unsigned int index;
1899                 u32 value;
1900
1901                 err = of_pci_get_devfn(port);
1902                 if (err < 0) {
1903                         dev_err(dev, "failed to parse address: %d\n", err);
1904                         return err;
1905                 }
1906
1907                 index = PCI_SLOT(err);
1908
1909                 if (index < 1 || index > soc->num_ports) {
1910                         dev_err(dev, "invalid port number: %d\n", index);
1911                         return -EINVAL;
1912                 }
1913
1914                 index--;
1915
1916                 err = of_property_read_u32(port, "nvidia,num-lanes", &value);
1917                 if (err < 0) {
1918                         dev_err(dev, "failed to parse # of lanes: %d\n",
1919                                 err);
1920                         return err;
1921                 }
1922
1923                 if (value > 16) {
1924                         dev_err(dev, "invalid # of lanes: %u\n", value);
1925                         return -EINVAL;
1926                 }
1927
1928                 lanes |= value << (index << 3);
1929
1930                 if (!of_device_is_available(port)) {
1931                         lane += value;
1932                         continue;
1933                 }
1934
1935                 mask |= ((1 << value) - 1) << lane;
1936                 lane += value;
1937
1938                 rp = devm_kzalloc(dev, sizeof(*rp), GFP_KERNEL);
1939                 if (!rp)
1940                         return -ENOMEM;
1941
1942                 err = of_address_to_resource(port, 0, &rp->regs);
1943                 if (err < 0) {
1944                         dev_err(dev, "failed to parse address: %d\n", err);
1945                         return err;
1946                 }
1947
1948                 INIT_LIST_HEAD(&rp->list);
1949                 rp->index = index;
1950                 rp->lanes = value;
1951                 rp->pcie = pcie;
1952                 rp->np = port;
1953
1954                 rp->base = devm_ioremap_resource(dev, &rp->regs);
1955                 if (IS_ERR(rp->base))
1956                         return PTR_ERR(rp->base);
1957
1958                 list_add_tail(&rp->list, &pcie->ports);
1959         }
1960
1961         err = tegra_pcie_get_xbar_config(pcie, lanes, &pcie->xbar_config);
1962         if (err < 0) {
1963                 dev_err(dev, "invalid lane configuration\n");
1964                 return err;
1965         }
1966
1967         err = tegra_pcie_get_regulators(pcie, mask);
1968         if (err < 0)
1969                 return err;
1970
1971         return 0;
1972 }
1973
1974 /*
1975  * FIXME: If there are no PCIe cards attached, then calling this function
1976  * can result in the increase of the bootup time as there are big timeout
1977  * loops.
1978  */
1979 #define TEGRA_PCIE_LINKUP_TIMEOUT       200     /* up to 1.2 seconds */
1980 static bool tegra_pcie_port_check_link(struct tegra_pcie_port *port)
1981 {
1982         struct device *dev = port->pcie->dev;
1983         unsigned int retries = 3;
1984         unsigned long value;
1985
1986         /* override presence detection */
1987         value = readl(port->base + RP_PRIV_MISC);
1988         value &= ~RP_PRIV_MISC_PRSNT_MAP_EP_ABSNT;
1989         value |= RP_PRIV_MISC_PRSNT_MAP_EP_PRSNT;
1990         writel(value, port->base + RP_PRIV_MISC);
1991
1992         do {
1993                 unsigned int timeout = TEGRA_PCIE_LINKUP_TIMEOUT;
1994
1995                 do {
1996                         value = readl(port->base + RP_VEND_XP);
1997
1998                         if (value & RP_VEND_XP_DL_UP)
1999                                 break;
2000
2001                         usleep_range(1000, 2000);
2002                 } while (--timeout);
2003
2004                 if (!timeout) {
2005                         dev_err(dev, "link %u down, retrying\n", port->index);
2006                         goto retry;
2007                 }
2008
2009                 timeout = TEGRA_PCIE_LINKUP_TIMEOUT;
2010
2011                 do {
2012                         value = readl(port->base + RP_LINK_CONTROL_STATUS);
2013
2014                         if (value & RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE)
2015                                 return true;
2016
2017                         usleep_range(1000, 2000);
2018                 } while (--timeout);
2019
2020 retry:
2021                 tegra_pcie_port_reset(port);
2022         } while (--retries);
2023
2024         return false;
2025 }
2026
2027 static void tegra_pcie_enable_ports(struct tegra_pcie *pcie)
2028 {
2029         struct device *dev = pcie->dev;
2030         struct tegra_pcie_port *port, *tmp;
2031
2032         list_for_each_entry_safe(port, tmp, &pcie->ports, list) {
2033                 dev_info(dev, "probing port %u, using %u lanes\n",
2034                          port->index, port->lanes);
2035
2036                 tegra_pcie_port_enable(port);
2037
2038                 if (tegra_pcie_port_check_link(port))
2039                         continue;
2040
2041                 dev_info(dev, "link %u down, ignoring\n", port->index);
2042
2043                 tegra_pcie_port_disable(port);
2044                 tegra_pcie_port_free(port);
2045         }
2046 }
2047
2048 static const struct tegra_pcie_soc tegra20_pcie = {
2049         .num_ports = 2,
2050         .msi_base_shift = 0,
2051         .pads_pll_ctl = PADS_PLL_CTL_TEGRA20,
2052         .tx_ref_sel = PADS_PLL_CTL_TXCLKREF_DIV10,
2053         .pads_refclk_cfg0 = 0xfa5cfa5c,
2054         .has_pex_clkreq_en = false,
2055         .has_pex_bias_ctrl = false,
2056         .has_intr_prsnt_sense = false,
2057         .has_cml_clk = false,
2058         .has_gen2 = false,
2059         .force_pca_enable = false,
2060 };
2061
2062 static const struct tegra_pcie_soc tegra30_pcie = {
2063         .num_ports = 3,
2064         .msi_base_shift = 8,
2065         .pads_pll_ctl = PADS_PLL_CTL_TEGRA30,
2066         .tx_ref_sel = PADS_PLL_CTL_TXCLKREF_BUF_EN,
2067         .pads_refclk_cfg0 = 0xfa5cfa5c,
2068         .pads_refclk_cfg1 = 0xfa5cfa5c,
2069         .has_pex_clkreq_en = true,
2070         .has_pex_bias_ctrl = true,
2071         .has_intr_prsnt_sense = true,
2072         .has_cml_clk = true,
2073         .has_gen2 = false,
2074         .force_pca_enable = false,
2075 };
2076
2077 static const struct tegra_pcie_soc tegra124_pcie = {
2078         .num_ports = 2,
2079         .msi_base_shift = 8,
2080         .pads_pll_ctl = PADS_PLL_CTL_TEGRA30,
2081         .tx_ref_sel = PADS_PLL_CTL_TXCLKREF_BUF_EN,
2082         .pads_refclk_cfg0 = 0x44ac44ac,
2083         .has_pex_clkreq_en = true,
2084         .has_pex_bias_ctrl = true,
2085         .has_intr_prsnt_sense = true,
2086         .has_cml_clk = true,
2087         .has_gen2 = true,
2088         .force_pca_enable = false,
2089 };
2090
2091 static const struct of_device_id tegra_pcie_of_match[] = {
2092         { .compatible = "nvidia,tegra124-pcie", .data = &tegra124_pcie },
2093         { .compatible = "nvidia,tegra30-pcie", .data = &tegra30_pcie },
2094         { .compatible = "nvidia,tegra20-pcie", .data = &tegra20_pcie },
2095         { },
2096 };
2097
2098 static void *tegra_pcie_ports_seq_start(struct seq_file *s, loff_t *pos)
2099 {
2100         struct tegra_pcie *pcie = s->private;
2101
2102         if (list_empty(&pcie->ports))
2103                 return NULL;
2104
2105         seq_printf(s, "Index  Status\n");
2106
2107         return seq_list_start(&pcie->ports, *pos);
2108 }
2109
2110 static void *tegra_pcie_ports_seq_next(struct seq_file *s, void *v, loff_t *pos)
2111 {
2112         struct tegra_pcie *pcie = s->private;
2113
2114         return seq_list_next(v, &pcie->ports, pos);
2115 }
2116
2117 static void tegra_pcie_ports_seq_stop(struct seq_file *s, void *v)
2118 {
2119 }
2120
2121 static int tegra_pcie_ports_seq_show(struct seq_file *s, void *v)
2122 {
2123         bool up = false, active = false;
2124         struct tegra_pcie_port *port;
2125         unsigned int value;
2126
2127         port = list_entry(v, struct tegra_pcie_port, list);
2128
2129         value = readl(port->base + RP_VEND_XP);
2130
2131         if (value & RP_VEND_XP_DL_UP)
2132                 up = true;
2133
2134         value = readl(port->base + RP_LINK_CONTROL_STATUS);
2135
2136         if (value & RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE)
2137                 active = true;
2138
2139         seq_printf(s, "%2u     ", port->index);
2140
2141         if (up)
2142                 seq_printf(s, "up");
2143
2144         if (active) {
2145                 if (up)
2146                         seq_printf(s, ", ");
2147
2148                 seq_printf(s, "active");
2149         }
2150
2151         seq_printf(s, "\n");
2152         return 0;
2153 }
2154
2155 static const struct seq_operations tegra_pcie_ports_seq_ops = {
2156         .start = tegra_pcie_ports_seq_start,
2157         .next = tegra_pcie_ports_seq_next,
2158         .stop = tegra_pcie_ports_seq_stop,
2159         .show = tegra_pcie_ports_seq_show,
2160 };
2161
2162 static int tegra_pcie_ports_open(struct inode *inode, struct file *file)
2163 {
2164         struct tegra_pcie *pcie = inode->i_private;
2165         struct seq_file *s;
2166         int err;
2167
2168         err = seq_open(file, &tegra_pcie_ports_seq_ops);
2169         if (err)
2170                 return err;
2171
2172         s = file->private_data;
2173         s->private = pcie;
2174
2175         return 0;
2176 }
2177
2178 static const struct file_operations tegra_pcie_ports_ops = {
2179         .owner = THIS_MODULE,
2180         .open = tegra_pcie_ports_open,
2181         .read = seq_read,
2182         .llseek = seq_lseek,
2183         .release = seq_release,
2184 };
2185
2186 static int tegra_pcie_debugfs_init(struct tegra_pcie *pcie)
2187 {
2188         struct dentry *file;
2189
2190         pcie->debugfs = debugfs_create_dir("pcie", NULL);
2191         if (!pcie->debugfs)
2192                 return -ENOMEM;
2193
2194         file = debugfs_create_file("ports", S_IFREG | S_IRUGO, pcie->debugfs,
2195                                    pcie, &tegra_pcie_ports_ops);
2196         if (!file)
2197                 goto remove;
2198
2199         return 0;
2200
2201 remove:
2202         debugfs_remove_recursive(pcie->debugfs);
2203         pcie->debugfs = NULL;
2204         return -ENOMEM;
2205 }
2206
2207 static int tegra_pcie_probe(struct platform_device *pdev)
2208 {
2209         struct device *dev = &pdev->dev;
2210         struct pci_host_bridge *host;
2211         struct tegra_pcie *pcie;
2212         struct pci_bus *child;
2213         int err;
2214
2215         host = pci_alloc_host_bridge(sizeof(*pcie));
2216         if (!host)
2217                 return -ENOMEM;
2218
2219         pcie = pci_host_bridge_priv(host);
2220
2221         pcie->soc = of_device_get_match_data(dev);
2222         INIT_LIST_HEAD(&pcie->buses);
2223         INIT_LIST_HEAD(&pcie->ports);
2224         pcie->dev = dev;
2225
2226         err = tegra_pcie_parse_dt(pcie);
2227         if (err < 0)
2228                 return err;
2229
2230         err = tegra_pcie_get_resources(pcie);
2231         if (err < 0) {
2232                 dev_err(dev, "failed to request resources: %d\n", err);
2233                 return err;
2234         }
2235
2236         err = tegra_pcie_enable_controller(pcie);
2237         if (err)
2238                 goto put_resources;
2239
2240         err = tegra_pcie_request_resources(pcie);
2241         if (err)
2242                 goto put_resources;
2243
2244         /* setup the AFI address translations */
2245         tegra_pcie_setup_translations(pcie);
2246
2247         if (IS_ENABLED(CONFIG_PCI_MSI)) {
2248                 err = tegra_pcie_enable_msi(pcie);
2249                 if (err < 0) {
2250                         dev_err(dev, "failed to enable MSI support: %d\n", err);
2251                         goto put_resources;
2252                 }
2253         }
2254
2255         tegra_pcie_enable_ports(pcie);
2256
2257         pci_add_flags(PCI_REASSIGN_ALL_RSRC | PCI_REASSIGN_ALL_BUS);
2258         host->busnr = pcie->busn.start;
2259         host->dev.parent = &pdev->dev;
2260         host->ops = &tegra_pcie_ops;
2261
2262         err = pci_register_host_bridge(host);
2263         if (err < 0) {
2264                 dev_err(dev, "failed to register host: %d\n", err);
2265                 goto disable_msi;
2266         }
2267
2268         pci_scan_child_bus(host->bus);
2269
2270         pci_fixup_irqs(pci_common_swizzle, tegra_pcie_map_irq);
2271         pci_bus_size_bridges(host->bus);
2272         pci_bus_assign_resources(host->bus);
2273
2274         list_for_each_entry(child, &host->bus->children, node)
2275                 pcie_bus_configure_settings(child);
2276
2277         pci_bus_add_devices(host->bus);
2278
2279         if (IS_ENABLED(CONFIG_DEBUG_FS)) {
2280                 err = tegra_pcie_debugfs_init(pcie);
2281                 if (err < 0)
2282                         dev_err(dev, "failed to setup debugfs: %d\n", err);
2283         }
2284
2285         return 0;
2286
2287 disable_msi:
2288         if (IS_ENABLED(CONFIG_PCI_MSI))
2289                 tegra_pcie_disable_msi(pcie);
2290 put_resources:
2291         tegra_pcie_put_resources(pcie);
2292         return err;
2293 }
2294
2295 static struct platform_driver tegra_pcie_driver = {
2296         .driver = {
2297                 .name = "tegra-pcie",
2298                 .of_match_table = tegra_pcie_of_match,
2299                 .suppress_bind_attrs = true,
2300         },
2301         .probe = tegra_pcie_probe,
2302 };
2303 builtin_platform_driver(tegra_pcie_driver);