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