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                 tegra_msi_free(msi, hwirq);
1175                 return -EINVAL;
1176         }
1177
1178         irq_set_msi_desc(irq, desc);
1179
1180         msg.address_lo = virt_to_phys((void *)msi->pages);
1181         /* 32 bit address only */
1182         msg.address_hi = 0;
1183         msg.data = hwirq;
1184
1185         write_msi_msg(irq, &msg);
1186
1187         return 0;
1188 }
1189
1190 static void tegra_msi_teardown_irq(struct msi_chip *chip, unsigned int irq)
1191 {
1192         struct tegra_msi *msi = to_tegra_msi(chip);
1193         struct irq_data *d = irq_get_irq_data(irq);
1194         irq_hw_number_t hwirq = irqd_to_hwirq(d);
1195
1196         irq_dispose_mapping(irq);
1197         tegra_msi_free(msi, hwirq);
1198 }
1199
1200 static struct irq_chip tegra_msi_irq_chip = {
1201         .name = "Tegra PCIe MSI",
1202         .irq_enable = unmask_msi_irq,
1203         .irq_disable = mask_msi_irq,
1204         .irq_mask = mask_msi_irq,
1205         .irq_unmask = unmask_msi_irq,
1206 };
1207
1208 static int tegra_msi_map(struct irq_domain *domain, unsigned int irq,
1209                          irq_hw_number_t hwirq)
1210 {
1211         irq_set_chip_and_handler(irq, &tegra_msi_irq_chip, handle_simple_irq);
1212         irq_set_chip_data(irq, domain->host_data);
1213         set_irq_flags(irq, IRQF_VALID);
1214
1215         tegra_cpuidle_pcie_irqs_in_use();
1216
1217         return 0;
1218 }
1219
1220 static const struct irq_domain_ops msi_domain_ops = {
1221         .map = tegra_msi_map,
1222 };
1223
1224 static int tegra_pcie_enable_msi(struct tegra_pcie *pcie)
1225 {
1226         struct platform_device *pdev = to_platform_device(pcie->dev);
1227         const struct tegra_pcie_soc_data *soc = pcie->soc_data;
1228         struct tegra_msi *msi = &pcie->msi;
1229         unsigned long base;
1230         int err;
1231         u32 reg;
1232
1233         mutex_init(&msi->lock);
1234
1235         msi->chip.dev = pcie->dev;
1236         msi->chip.setup_irq = tegra_msi_setup_irq;
1237         msi->chip.teardown_irq = tegra_msi_teardown_irq;
1238
1239         msi->domain = irq_domain_add_linear(pcie->dev->of_node, INT_PCI_MSI_NR,
1240                                             &msi_domain_ops, &msi->chip);
1241         if (!msi->domain) {
1242                 dev_err(&pdev->dev, "failed to create IRQ domain\n");
1243                 return -ENOMEM;
1244         }
1245
1246         err = platform_get_irq_byname(pdev, "msi");
1247         if (err < 0) {
1248                 dev_err(&pdev->dev, "failed to get IRQ: %d\n", err);
1249                 goto err;
1250         }
1251
1252         msi->irq = err;
1253
1254         err = request_irq(msi->irq, tegra_pcie_msi_irq, 0,
1255                           tegra_msi_irq_chip.name, pcie);
1256         if (err < 0) {
1257                 dev_err(&pdev->dev, "failed to request IRQ: %d\n", err);
1258                 goto err;
1259         }
1260
1261         /* setup AFI/FPCI range */
1262         msi->pages = __get_free_pages(GFP_KERNEL, 0);
1263         base = virt_to_phys((void *)msi->pages);
1264
1265         afi_writel(pcie, base >> soc->msi_base_shift, AFI_MSI_FPCI_BAR_ST);
1266         afi_writel(pcie, base, AFI_MSI_AXI_BAR_ST);
1267         /* this register is in 4K increments */
1268         afi_writel(pcie, 1, AFI_MSI_BAR_SZ);
1269
1270         /* enable all MSI vectors */
1271         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC0);
1272         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC1);
1273         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC2);
1274         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC3);
1275         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC4);
1276         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC5);
1277         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC6);
1278         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC7);
1279
1280         /* and unmask the MSI interrupt */
1281         reg = afi_readl(pcie, AFI_INTR_MASK);
1282         reg |= AFI_INTR_MASK_MSI_MASK;
1283         afi_writel(pcie, reg, AFI_INTR_MASK);
1284
1285         return 0;
1286
1287 err:
1288         irq_domain_remove(msi->domain);
1289         return err;
1290 }
1291
1292 static int tegra_pcie_disable_msi(struct tegra_pcie *pcie)
1293 {
1294         struct tegra_msi *msi = &pcie->msi;
1295         unsigned int i, irq;
1296         u32 value;
1297
1298         /* mask the MSI interrupt */
1299         value = afi_readl(pcie, AFI_INTR_MASK);
1300         value &= ~AFI_INTR_MASK_MSI_MASK;
1301         afi_writel(pcie, value, AFI_INTR_MASK);
1302
1303         /* disable all MSI vectors */
1304         afi_writel(pcie, 0, AFI_MSI_EN_VEC0);
1305         afi_writel(pcie, 0, AFI_MSI_EN_VEC1);
1306         afi_writel(pcie, 0, AFI_MSI_EN_VEC2);
1307         afi_writel(pcie, 0, AFI_MSI_EN_VEC3);
1308         afi_writel(pcie, 0, AFI_MSI_EN_VEC4);
1309         afi_writel(pcie, 0, AFI_MSI_EN_VEC5);
1310         afi_writel(pcie, 0, AFI_MSI_EN_VEC6);
1311         afi_writel(pcie, 0, AFI_MSI_EN_VEC7);
1312
1313         free_pages(msi->pages, 0);
1314
1315         if (msi->irq > 0)
1316                 free_irq(msi->irq, pcie);
1317
1318         for (i = 0; i < INT_PCI_MSI_NR; i++) {
1319                 irq = irq_find_mapping(msi->domain, i);
1320                 if (irq > 0)
1321                         irq_dispose_mapping(irq);
1322         }
1323
1324         irq_domain_remove(msi->domain);
1325
1326         return 0;
1327 }
1328
1329 static int tegra_pcie_get_xbar_config(struct tegra_pcie *pcie, u32 lanes,
1330                                       u32 *xbar)
1331 {
1332         struct device_node *np = pcie->dev->of_node;
1333
1334         if (of_device_is_compatible(np, "nvidia,tegra30-pcie")) {
1335                 switch (lanes) {
1336                 case 0x00000204:
1337                         dev_info(pcie->dev, "4x1, 2x1 configuration\n");
1338                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_420;
1339                         return 0;
1340
1341                 case 0x00020202:
1342                         dev_info(pcie->dev, "2x3 configuration\n");
1343                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_222;
1344                         return 0;
1345
1346                 case 0x00010104:
1347                         dev_info(pcie->dev, "4x1, 1x2 configuration\n");
1348                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_411;
1349                         return 0;
1350                 }
1351         } else if (of_device_is_compatible(np, "nvidia,tegra20-pcie")) {
1352                 switch (lanes) {
1353                 case 0x00000004:
1354                         dev_info(pcie->dev, "single-mode configuration\n");
1355                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_SINGLE;
1356                         return 0;
1357
1358                 case 0x00000202:
1359                         dev_info(pcie->dev, "dual-mode configuration\n");
1360                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_DUAL;
1361                         return 0;
1362                 }
1363         }
1364
1365         return -EINVAL;
1366 }
1367
1368 /*
1369  * Check whether a given set of supplies is available in a device tree node.
1370  * This is used to check whether the new or the legacy device tree bindings
1371  * should be used.
1372  */
1373 static bool of_regulator_bulk_available(struct device_node *np,
1374                                         struct regulator_bulk_data *supplies,
1375                                         unsigned int num_supplies)
1376 {
1377         char property[32];
1378         unsigned int i;
1379
1380         for (i = 0; i < num_supplies; i++) {
1381                 snprintf(property, 32, "%s-supply", supplies[i].supply);
1382
1383                 if (of_find_property(np, property, NULL) == NULL)
1384                         return false;
1385         }
1386
1387         return true;
1388 }
1389
1390 /*
1391  * Old versions of the device tree binding for this device used a set of power
1392  * supplies that didn't match the hardware inputs. This happened to work for a
1393  * number of cases but is not future proof. However to preserve backwards-
1394  * compatibility with old device trees, this function will try to use the old
1395  * set of supplies.
1396  */
1397 static int tegra_pcie_get_legacy_regulators(struct tegra_pcie *pcie)
1398 {
1399         struct device_node *np = pcie->dev->of_node;
1400
1401         if (of_device_is_compatible(np, "nvidia,tegra30-pcie"))
1402                 pcie->num_supplies = 3;
1403         else if (of_device_is_compatible(np, "nvidia,tegra20-pcie"))
1404                 pcie->num_supplies = 2;
1405
1406         if (pcie->num_supplies == 0) {
1407                 dev_err(pcie->dev, "device %s not supported in legacy mode\n",
1408                         np->full_name);
1409                 return -ENODEV;
1410         }
1411
1412         pcie->supplies = devm_kcalloc(pcie->dev, pcie->num_supplies,
1413                                       sizeof(*pcie->supplies),
1414                                       GFP_KERNEL);
1415         if (!pcie->supplies)
1416                 return -ENOMEM;
1417
1418         pcie->supplies[0].supply = "pex-clk";
1419         pcie->supplies[1].supply = "vdd";
1420
1421         if (pcie->num_supplies > 2)
1422                 pcie->supplies[2].supply = "avdd";
1423
1424         return devm_regulator_bulk_get(pcie->dev, pcie->num_supplies,
1425                                        pcie->supplies);
1426 }
1427
1428 /*
1429  * Obtains the list of regulators required for a particular generation of the
1430  * IP block.
1431  *
1432  * This would've been nice to do simply by providing static tables for use
1433  * with the regulator_bulk_*() API, but unfortunately Tegra30 is a bit quirky
1434  * in that it has two pairs or AVDD_PEX and VDD_PEX supplies (PEXA and PEXB)
1435  * and either seems to be optional depending on which ports are being used.
1436  */
1437 static int tegra_pcie_get_regulators(struct tegra_pcie *pcie, u32 lane_mask)
1438 {
1439         struct device_node *np = pcie->dev->of_node;
1440         unsigned int i = 0;
1441
1442         if (of_device_is_compatible(np, "nvidia,tegra30-pcie")) {
1443                 bool need_pexa = false, need_pexb = false;
1444
1445                 /* VDD_PEXA and AVDD_PEXA supply lanes 0 to 3 */
1446                 if (lane_mask & 0x0f)
1447                         need_pexa = true;
1448
1449                 /* VDD_PEXB and AVDD_PEXB supply lanes 4 to 5 */
1450                 if (lane_mask & 0x30)
1451                         need_pexb = true;
1452
1453                 pcie->num_supplies = 4 + (need_pexa ? 2 : 0) +
1454                                          (need_pexb ? 2 : 0);
1455
1456                 pcie->supplies = devm_kcalloc(pcie->dev, pcie->num_supplies,
1457                                               sizeof(*pcie->supplies),
1458                                               GFP_KERNEL);
1459                 if (!pcie->supplies)
1460                         return -ENOMEM;
1461
1462                 pcie->supplies[i++].supply = "avdd-pex-pll";
1463                 pcie->supplies[i++].supply = "hvdd-pex";
1464                 pcie->supplies[i++].supply = "vddio-pex-ctl";
1465                 pcie->supplies[i++].supply = "avdd-plle";
1466
1467                 if (need_pexa) {
1468                         pcie->supplies[i++].supply = "avdd-pexa";
1469                         pcie->supplies[i++].supply = "vdd-pexa";
1470                 }
1471
1472                 if (need_pexb) {
1473                         pcie->supplies[i++].supply = "avdd-pexb";
1474                         pcie->supplies[i++].supply = "vdd-pexb";
1475                 }
1476         } else if (of_device_is_compatible(np, "nvidia,tegra20-pcie")) {
1477                 pcie->num_supplies = 5;
1478
1479                 pcie->supplies = devm_kcalloc(pcie->dev, pcie->num_supplies,
1480                                               sizeof(*pcie->supplies),
1481                                               GFP_KERNEL);
1482                 if (!pcie->supplies)
1483                         return -ENOMEM;
1484
1485                 pcie->supplies[0].supply = "avdd-pex";
1486                 pcie->supplies[1].supply = "vdd-pex";
1487                 pcie->supplies[2].supply = "avdd-pex-pll";
1488                 pcie->supplies[3].supply = "avdd-plle";
1489                 pcie->supplies[4].supply = "vddio-pex-clk";
1490         }
1491
1492         if (of_regulator_bulk_available(pcie->dev->of_node, pcie->supplies,
1493                                         pcie->num_supplies))
1494                 return devm_regulator_bulk_get(pcie->dev, pcie->num_supplies,
1495                                                pcie->supplies);
1496
1497         /*
1498          * If not all regulators are available for this new scheme, assume
1499          * that the device tree complies with an older version of the device
1500          * tree binding.
1501          */
1502         dev_info(pcie->dev, "using legacy DT binding for power supplies\n");
1503
1504         devm_kfree(pcie->dev, pcie->supplies);
1505         pcie->num_supplies = 0;
1506
1507         return tegra_pcie_get_legacy_regulators(pcie);
1508 }
1509
1510 static int tegra_pcie_parse_dt(struct tegra_pcie *pcie)
1511 {
1512         const struct tegra_pcie_soc_data *soc = pcie->soc_data;
1513         struct device_node *np = pcie->dev->of_node, *port;
1514         struct of_pci_range_parser parser;
1515         struct of_pci_range range;
1516         u32 lanes = 0, mask = 0;
1517         unsigned int lane = 0;
1518         struct resource res;
1519         int err;
1520
1521         if (of_pci_range_parser_init(&parser, np)) {
1522                 dev_err(pcie->dev, "missing \"ranges\" property\n");
1523                 return -EINVAL;
1524         }
1525
1526         for_each_of_pci_range(&parser, &range) {
1527                 of_pci_range_to_resource(&range, np, &res);
1528
1529                 switch (res.flags & IORESOURCE_TYPE_BITS) {
1530                 case IORESOURCE_IO:
1531                         memcpy(&pcie->io, &res, sizeof(res));
1532                         pcie->io.name = "I/O";
1533                         break;
1534
1535                 case IORESOURCE_MEM:
1536                         if (res.flags & IORESOURCE_PREFETCH) {
1537                                 memcpy(&pcie->prefetch, &res, sizeof(res));
1538                                 pcie->prefetch.name = "PREFETCH";
1539                         } else {
1540                                 memcpy(&pcie->mem, &res, sizeof(res));
1541                                 pcie->mem.name = "MEM";
1542                         }
1543                         break;
1544                 }
1545         }
1546
1547         err = of_pci_parse_bus_range(np, &pcie->busn);
1548         if (err < 0) {
1549                 dev_err(pcie->dev, "failed to parse ranges property: %d\n",
1550                         err);
1551                 pcie->busn.name = np->name;
1552                 pcie->busn.start = 0;
1553                 pcie->busn.end = 0xff;
1554                 pcie->busn.flags = IORESOURCE_BUS;
1555         }
1556
1557         /* parse root ports */
1558         for_each_child_of_node(np, port) {
1559                 struct tegra_pcie_port *rp;
1560                 unsigned int index;
1561                 u32 value;
1562
1563                 err = of_pci_get_devfn(port);
1564                 if (err < 0) {
1565                         dev_err(pcie->dev, "failed to parse address: %d\n",
1566                                 err);
1567                         return err;
1568                 }
1569
1570                 index = PCI_SLOT(err);
1571
1572                 if (index < 1 || index > soc->num_ports) {
1573                         dev_err(pcie->dev, "invalid port number: %d\n", index);
1574                         return -EINVAL;
1575                 }
1576
1577                 index--;
1578
1579                 err = of_property_read_u32(port, "nvidia,num-lanes", &value);
1580                 if (err < 0) {
1581                         dev_err(pcie->dev, "failed to parse # of lanes: %d\n",
1582                                 err);
1583                         return err;
1584                 }
1585
1586                 if (value > 16) {
1587                         dev_err(pcie->dev, "invalid # of lanes: %u\n", value);
1588                         return -EINVAL;
1589                 }
1590
1591                 lanes |= value << (index << 3);
1592
1593                 if (!of_device_is_available(port)) {
1594                         lane += value;
1595                         continue;
1596                 }
1597
1598                 mask |= ((1 << value) - 1) << lane;
1599                 lane += value;
1600
1601                 rp = devm_kzalloc(pcie->dev, sizeof(*rp), GFP_KERNEL);
1602                 if (!rp)
1603                         return -ENOMEM;
1604
1605                 err = of_address_to_resource(port, 0, &rp->regs);
1606                 if (err < 0) {
1607                         dev_err(pcie->dev, "failed to parse address: %d\n",
1608                                 err);
1609                         return err;
1610                 }
1611
1612                 INIT_LIST_HEAD(&rp->list);
1613                 rp->index = index;
1614                 rp->lanes = value;
1615                 rp->pcie = pcie;
1616
1617                 rp->base = devm_ioremap_resource(pcie->dev, &rp->regs);
1618                 if (IS_ERR(rp->base))
1619                         return PTR_ERR(rp->base);
1620
1621                 list_add_tail(&rp->list, &pcie->ports);
1622         }
1623
1624         err = tegra_pcie_get_xbar_config(pcie, lanes, &pcie->xbar_config);
1625         if (err < 0) {
1626                 dev_err(pcie->dev, "invalid lane configuration\n");
1627                 return err;
1628         }
1629
1630         err = tegra_pcie_get_regulators(pcie, mask);
1631         if (err < 0)
1632                 return err;
1633
1634         return 0;
1635 }
1636
1637 /*
1638  * FIXME: If there are no PCIe cards attached, then calling this function
1639  * can result in the increase of the bootup time as there are big timeout
1640  * loops.
1641  */
1642 #define TEGRA_PCIE_LINKUP_TIMEOUT       200     /* up to 1.2 seconds */
1643 static bool tegra_pcie_port_check_link(struct tegra_pcie_port *port)
1644 {
1645         unsigned int retries = 3;
1646         unsigned long value;
1647
1648         do {
1649                 unsigned int timeout = TEGRA_PCIE_LINKUP_TIMEOUT;
1650
1651                 do {
1652                         value = readl(port->base + RP_VEND_XP);
1653
1654                         if (value & RP_VEND_XP_DL_UP)
1655                                 break;
1656
1657                         usleep_range(1000, 2000);
1658                 } while (--timeout);
1659
1660                 if (!timeout) {
1661                         dev_err(port->pcie->dev, "link %u down, retrying\n",
1662                                 port->index);
1663                         goto retry;
1664                 }
1665
1666                 timeout = TEGRA_PCIE_LINKUP_TIMEOUT;
1667
1668                 do {
1669                         value = readl(port->base + RP_LINK_CONTROL_STATUS);
1670
1671                         if (value & RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE)
1672                                 return true;
1673
1674                         usleep_range(1000, 2000);
1675                 } while (--timeout);
1676
1677 retry:
1678                 tegra_pcie_port_reset(port);
1679         } while (--retries);
1680
1681         return false;
1682 }
1683
1684 static int tegra_pcie_enable(struct tegra_pcie *pcie)
1685 {
1686         struct tegra_pcie_port *port, *tmp;
1687         struct hw_pci hw;
1688
1689         list_for_each_entry_safe(port, tmp, &pcie->ports, list) {
1690                 dev_info(pcie->dev, "probing port %u, using %u lanes\n",
1691                          port->index, port->lanes);
1692
1693                 tegra_pcie_port_enable(port);
1694
1695                 if (tegra_pcie_port_check_link(port))
1696                         continue;
1697
1698                 dev_info(pcie->dev, "link %u down, ignoring\n", port->index);
1699
1700                 tegra_pcie_port_disable(port);
1701                 tegra_pcie_port_free(port);
1702         }
1703
1704         memset(&hw, 0, sizeof(hw));
1705
1706         hw.nr_controllers = 1;
1707         hw.private_data = (void **)&pcie;
1708         hw.setup = tegra_pcie_setup;
1709         hw.map_irq = tegra_pcie_map_irq;
1710         hw.add_bus = tegra_pcie_add_bus;
1711         hw.scan = tegra_pcie_scan_bus;
1712         hw.ops = &tegra_pcie_ops;
1713
1714         pci_common_init_dev(pcie->dev, &hw);
1715
1716         return 0;
1717 }
1718
1719 static const struct tegra_pcie_soc_data tegra20_pcie_data = {
1720         .num_ports = 2,
1721         .msi_base_shift = 0,
1722         .pads_pll_ctl = PADS_PLL_CTL_TEGRA20,
1723         .tx_ref_sel = PADS_PLL_CTL_TXCLKREF_DIV10,
1724         .has_pex_clkreq_en = false,
1725         .has_pex_bias_ctrl = false,
1726         .has_intr_prsnt_sense = false,
1727         .has_cml_clk = false,
1728 };
1729
1730 static const struct tegra_pcie_soc_data tegra30_pcie_data = {
1731         .num_ports = 3,
1732         .msi_base_shift = 8,
1733         .pads_pll_ctl = PADS_PLL_CTL_TEGRA30,
1734         .tx_ref_sel = PADS_PLL_CTL_TXCLKREF_BUF_EN,
1735         .has_pex_clkreq_en = true,
1736         .has_pex_bias_ctrl = true,
1737         .has_intr_prsnt_sense = true,
1738         .has_cml_clk = true,
1739 };
1740
1741 static const struct of_device_id tegra_pcie_of_match[] = {
1742         { .compatible = "nvidia,tegra30-pcie", .data = &tegra30_pcie_data },
1743         { .compatible = "nvidia,tegra20-pcie", .data = &tegra20_pcie_data },
1744         { },
1745 };
1746 MODULE_DEVICE_TABLE(of, tegra_pcie_of_match);
1747
1748 static void *tegra_pcie_ports_seq_start(struct seq_file *s, loff_t *pos)
1749 {
1750         struct tegra_pcie *pcie = s->private;
1751
1752         if (list_empty(&pcie->ports))
1753                 return NULL;
1754
1755         seq_printf(s, "Index  Status\n");
1756
1757         return seq_list_start(&pcie->ports, *pos);
1758 }
1759
1760 static void *tegra_pcie_ports_seq_next(struct seq_file *s, void *v, loff_t *pos)
1761 {
1762         struct tegra_pcie *pcie = s->private;
1763
1764         return seq_list_next(v, &pcie->ports, pos);
1765 }
1766
1767 static void tegra_pcie_ports_seq_stop(struct seq_file *s, void *v)
1768 {
1769 }
1770
1771 static int tegra_pcie_ports_seq_show(struct seq_file *s, void *v)
1772 {
1773         bool up = false, active = false;
1774         struct tegra_pcie_port *port;
1775         unsigned int value;
1776
1777         port = list_entry(v, struct tegra_pcie_port, list);
1778
1779         value = readl(port->base + RP_VEND_XP);
1780
1781         if (value & RP_VEND_XP_DL_UP)
1782                 up = true;
1783
1784         value = readl(port->base + RP_LINK_CONTROL_STATUS);
1785
1786         if (value & RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE)
1787                 active = true;
1788
1789         seq_printf(s, "%2u     ", port->index);
1790
1791         if (up)
1792                 seq_printf(s, "up");
1793
1794         if (active) {
1795                 if (up)
1796                         seq_printf(s, ", ");
1797
1798                 seq_printf(s, "active");
1799         }
1800
1801         seq_printf(s, "\n");
1802         return 0;
1803 }
1804
1805 static const struct seq_operations tegra_pcie_ports_seq_ops = {
1806         .start = tegra_pcie_ports_seq_start,
1807         .next = tegra_pcie_ports_seq_next,
1808         .stop = tegra_pcie_ports_seq_stop,
1809         .show = tegra_pcie_ports_seq_show,
1810 };
1811
1812 static int tegra_pcie_ports_open(struct inode *inode, struct file *file)
1813 {
1814         struct tegra_pcie *pcie = inode->i_private;
1815         struct seq_file *s;
1816         int err;
1817
1818         err = seq_open(file, &tegra_pcie_ports_seq_ops);
1819         if (err)
1820                 return err;
1821
1822         s = file->private_data;
1823         s->private = pcie;
1824
1825         return 0;
1826 }
1827
1828 static const struct file_operations tegra_pcie_ports_ops = {
1829         .owner = THIS_MODULE,
1830         .open = tegra_pcie_ports_open,
1831         .read = seq_read,
1832         .llseek = seq_lseek,
1833         .release = seq_release,
1834 };
1835
1836 static int tegra_pcie_debugfs_init(struct tegra_pcie *pcie)
1837 {
1838         struct dentry *file;
1839
1840         pcie->debugfs = debugfs_create_dir("pcie", NULL);
1841         if (!pcie->debugfs)
1842                 return -ENOMEM;
1843
1844         file = debugfs_create_file("ports", S_IFREG | S_IRUGO, pcie->debugfs,
1845                                    pcie, &tegra_pcie_ports_ops);
1846         if (!file)
1847                 goto remove;
1848
1849         return 0;
1850
1851 remove:
1852         debugfs_remove_recursive(pcie->debugfs);
1853         pcie->debugfs = NULL;
1854         return -ENOMEM;
1855 }
1856
1857 static int tegra_pcie_probe(struct platform_device *pdev)
1858 {
1859         const struct of_device_id *match;
1860         struct tegra_pcie *pcie;
1861         int err;
1862
1863         match = of_match_device(tegra_pcie_of_match, &pdev->dev);
1864         if (!match)
1865                 return -ENODEV;
1866
1867         pcie = devm_kzalloc(&pdev->dev, sizeof(*pcie), GFP_KERNEL);
1868         if (!pcie)
1869                 return -ENOMEM;
1870
1871         INIT_LIST_HEAD(&pcie->buses);
1872         INIT_LIST_HEAD(&pcie->ports);
1873         pcie->soc_data = match->data;
1874         pcie->dev = &pdev->dev;
1875
1876         err = tegra_pcie_parse_dt(pcie);
1877         if (err < 0)
1878                 return err;
1879
1880         pcibios_min_mem = 0;
1881
1882         err = tegra_pcie_get_resources(pcie);
1883         if (err < 0) {
1884                 dev_err(&pdev->dev, "failed to request resources: %d\n", err);
1885                 return err;
1886         }
1887
1888         err = tegra_pcie_enable_controller(pcie);
1889         if (err)
1890                 goto put_resources;
1891
1892         /* setup the AFI address translations */
1893         tegra_pcie_setup_translations(pcie);
1894
1895         if (IS_ENABLED(CONFIG_PCI_MSI)) {
1896                 err = tegra_pcie_enable_msi(pcie);
1897                 if (err < 0) {
1898                         dev_err(&pdev->dev,
1899                                 "failed to enable MSI support: %d\n",
1900                                 err);
1901                         goto put_resources;
1902                 }
1903         }
1904
1905         err = tegra_pcie_enable(pcie);
1906         if (err < 0) {
1907                 dev_err(&pdev->dev, "failed to enable PCIe ports: %d\n", err);
1908                 goto disable_msi;
1909         }
1910
1911         if (IS_ENABLED(CONFIG_DEBUG_FS)) {
1912                 err = tegra_pcie_debugfs_init(pcie);
1913                 if (err < 0)
1914                         dev_err(&pdev->dev, "failed to setup debugfs: %d\n",
1915                                 err);
1916         }
1917
1918         platform_set_drvdata(pdev, pcie);
1919         return 0;
1920
1921 disable_msi:
1922         if (IS_ENABLED(CONFIG_PCI_MSI))
1923                 tegra_pcie_disable_msi(pcie);
1924 put_resources:
1925         tegra_pcie_put_resources(pcie);
1926         return err;
1927 }
1928
1929 static struct platform_driver tegra_pcie_driver = {
1930         .driver = {
1931                 .name = "tegra-pcie",
1932                 .owner = THIS_MODULE,
1933                 .of_match_table = tegra_pcie_of_match,
1934                 .suppress_bind_attrs = true,
1935         },
1936         .probe = tegra_pcie_probe,
1937 };
1938 module_platform_driver(tegra_pcie_driver);
1939
1940 MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>");
1941 MODULE_DESCRIPTION("NVIDIA Tegra PCIe driver");
1942 MODULE_LICENSE("GPL v2");