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