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