git.sur5r.net Git - u-boot/blob - drivers/pci/pci_tegra.c

   1 /*
   2  * Copyright (c) 2010, CompuLab, Ltd.
   3  * Author: Mike Rapoport <mike@compulab.co.il>
   4  *
   5  * Based on NVIDIA PCIe driver
   6  * Copyright (c) 2008-2009, NVIDIA Corporation.
   7  *
   8  * Copyright (c) 2013-2014, NVIDIA Corporation.
   9  *
  10  * SPDX-License-Identifier:     GPL-2.0
  11  */
  12
  13 #define pr_fmt(fmt) "tegra-pcie: " fmt
  14
  15 #include <common.h>
  16 #include <dm.h>
  17 #include <errno.h>
  18 #include <fdtdec.h>
  19 #include <malloc.h>
  20 #include <pci.h>
  21
  22 #include <asm/io.h>
  23 #include <asm/gpio.h>
  24
  25 #include <asm/arch/clock.h>
  26 #include <asm/arch/powergate.h>
  27 #include <asm/arch-tegra/xusb-padctl.h>
  28
  29 #include <linux/list.h>
  30
  31 #include <dt-bindings/pinctrl/pinctrl-tegra-xusb.h>
  32
  33 DECLARE_GLOBAL_DATA_PTR;
  34
  35 #define AFI_AXI_BAR0_SZ 0x00
  36 #define AFI_AXI_BAR1_SZ 0x04
  37 #define AFI_AXI_BAR2_SZ 0x08
  38 #define AFI_AXI_BAR3_SZ 0x0c
  39 #define AFI_AXI_BAR4_SZ 0x10
  40 #define AFI_AXI_BAR5_SZ 0x14
  41
  42 #define AFI_AXI_BAR0_START      0x18
  43 #define AFI_AXI_BAR1_START      0x1c
  44 #define AFI_AXI_BAR2_START      0x20
  45 #define AFI_AXI_BAR3_START      0x24
  46 #define AFI_AXI_BAR4_START      0x28
  47 #define AFI_AXI_BAR5_START      0x2c
  48
  49 #define AFI_FPCI_BAR0   0x30
  50 #define AFI_FPCI_BAR1   0x34
  51 #define AFI_FPCI_BAR2   0x38
  52 #define AFI_FPCI_BAR3   0x3c
  53 #define AFI_FPCI_BAR4   0x40
  54 #define AFI_FPCI_BAR5   0x44
  55
  56 #define AFI_CACHE_BAR0_SZ       0x48
  57 #define AFI_CACHE_BAR0_ST       0x4c
  58 #define AFI_CACHE_BAR1_SZ       0x50
  59 #define AFI_CACHE_BAR1_ST       0x54
  60
  61 #define AFI_MSI_BAR_SZ          0x60
  62 #define AFI_MSI_FPCI_BAR_ST     0x64
  63 #define AFI_MSI_AXI_BAR_ST      0x68
  64
  65 #define AFI_CONFIGURATION               0xac
  66 #define  AFI_CONFIGURATION_EN_FPCI      (1 << 0)
  67
  68 #define AFI_FPCI_ERROR_MASKS    0xb0
  69
  70 #define AFI_INTR_MASK           0xb4
  71 #define  AFI_INTR_MASK_INT_MASK (1 << 0)
  72 #define  AFI_INTR_MASK_MSI_MASK (1 << 8)
  73
  74 #define AFI_SM_INTR_ENABLE      0xc4
  75 #define  AFI_SM_INTR_INTA_ASSERT        (1 << 0)
  76 #define  AFI_SM_INTR_INTB_ASSERT        (1 << 1)
  77 #define  AFI_SM_INTR_INTC_ASSERT        (1 << 2)
  78 #define  AFI_SM_INTR_INTD_ASSERT        (1 << 3)
  79 #define  AFI_SM_INTR_INTA_DEASSERT      (1 << 4)
  80 #define  AFI_SM_INTR_INTB_DEASSERT      (1 << 5)
  81 #define  AFI_SM_INTR_INTC_DEASSERT      (1 << 6)
  82 #define  AFI_SM_INTR_INTD_DEASSERT      (1 << 7)
  83
  84 #define AFI_AFI_INTR_ENABLE             0xc8
  85 #define  AFI_INTR_EN_INI_SLVERR         (1 << 0)
  86 #define  AFI_INTR_EN_INI_DECERR         (1 << 1)
  87 #define  AFI_INTR_EN_TGT_SLVERR         (1 << 2)
  88 #define  AFI_INTR_EN_TGT_DECERR         (1 << 3)
  89 #define  AFI_INTR_EN_TGT_WRERR          (1 << 4)
  90 #define  AFI_INTR_EN_DFPCI_DECERR       (1 << 5)
  91 #define  AFI_INTR_EN_AXI_DECERR         (1 << 6)
  92 #define  AFI_INTR_EN_FPCI_TIMEOUT       (1 << 7)
  93 #define  AFI_INTR_EN_PRSNT_SENSE        (1 << 8)
  94
  95 #define AFI_PCIE_CONFIG                                 0x0f8
  96 #define  AFI_PCIE_CONFIG_PCIE_DISABLE(x)                (1 << ((x) + 1))
  97 #define  AFI_PCIE_CONFIG_PCIE_DISABLE_ALL               0xe
  98 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_MASK       (0xf << 20)
  99 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_SINGLE     (0x0 << 20)
 100 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_420        (0x0 << 20)
 101 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_X2_X1      (0x0 << 20)
 102 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_DUAL       (0x1 << 20)
 103 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_222        (0x1 << 20)
 104 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_X4_X1      (0x1 << 20)
 105 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_411        (0x2 << 20)
 106
 107 #define AFI_FUSE                        0x104
 108 #define  AFI_FUSE_PCIE_T0_GEN2_DIS      (1 << 2)
 109
 110 #define AFI_PEX0_CTRL                   0x110
 111 #define AFI_PEX1_CTRL                   0x118
 112 #define AFI_PEX2_CTRL                   0x128
 113 #define  AFI_PEX_CTRL_RST               (1 << 0)
 114 #define  AFI_PEX_CTRL_CLKREQ_EN         (1 << 1)
 115 #define  AFI_PEX_CTRL_REFCLK_EN         (1 << 3)
 116 #define  AFI_PEX_CTRL_OVERRIDE_EN       (1 << 4)
 117
 118 #define AFI_PLLE_CONTROL                0x160
 119 #define  AFI_PLLE_CONTROL_BYPASS_PADS2PLLE_CONTROL (1 << 9)
 120 #define  AFI_PLLE_CONTROL_PADS2PLLE_CONTROL_EN (1 << 1)
 121
 122 #define AFI_PEXBIAS_CTRL_0              0x168
 123
 124 #define PADS_CTL_SEL            0x0000009C
 125
 126 #define PADS_CTL                0x000000A0
 127 #define  PADS_CTL_IDDQ_1L       (1 <<  0)
 128 #define  PADS_CTL_TX_DATA_EN_1L (1 <<  6)
 129 #define  PADS_CTL_RX_DATA_EN_1L (1 << 10)
 130
 131 #define PADS_PLL_CTL_TEGRA20                    0x000000B8
 132 #define PADS_PLL_CTL_TEGRA30                    0x000000B4
 133 #define  PADS_PLL_CTL_RST_B4SM                  (0x1 <<  1)
 134 #define  PADS_PLL_CTL_LOCKDET                   (0x1 <<  8)
 135 #define  PADS_PLL_CTL_REFCLK_MASK               (0x3 << 16)
 136 #define  PADS_PLL_CTL_REFCLK_INTERNAL_CML       (0x0 << 16)
 137 #define  PADS_PLL_CTL_REFCLK_INTERNAL_CMOS      (0x1 << 16)
 138 #define  PADS_PLL_CTL_REFCLK_EXTERNAL           (0x2 << 16)
 139 #define  PADS_PLL_CTL_TXCLKREF_MASK             (0x1 << 20)
 140 #define  PADS_PLL_CTL_TXCLKREF_DIV10            (0x0 << 20)
 141 #define  PADS_PLL_CTL_TXCLKREF_DIV5             (0x1 << 20)
 142 #define  PADS_PLL_CTL_TXCLKREF_BUF_EN           (0x1 << 22)
 143
 144 #define PADS_REFCLK_CFG0                        0x000000C8
 145 #define PADS_REFCLK_CFG1                        0x000000CC
 146
 147 /*
 148  * Fields in PADS_REFCLK_CFG*. Those registers form an array of 16-bit
 149  * entries, one entry per PCIe port. These field definitions and desired
 150  * values aren't in the TRM, but do come from NVIDIA.
 151  */
 152 #define PADS_REFCLK_CFG_TERM_SHIFT              2  /* 6:2 */
 153 #define PADS_REFCLK_CFG_E_TERM_SHIFT            7
 154 #define PADS_REFCLK_CFG_PREDI_SHIFT             8  /* 11:8 */
 155 #define PADS_REFCLK_CFG_DRVI_SHIFT              12 /* 15:12 */
 156
 157 /* Default value provided by HW engineering is 0xfa5c */
 158 #define PADS_REFCLK_CFG_VALUE \
 159         ( \
 160                 (0x17 << PADS_REFCLK_CFG_TERM_SHIFT)   | \
 161                 (0    << PADS_REFCLK_CFG_E_TERM_SHIFT) | \
 162                 (0xa  << PADS_REFCLK_CFG_PREDI_SHIFT)  | \
 163                 (0xf  << PADS_REFCLK_CFG_DRVI_SHIFT)     \
 164         )
 165
 166 #define RP_VEND_XP      0x00000F00
 167 #define  RP_VEND_XP_DL_UP       (1 << 30)
 168
 169 #define RP_VEND_CTL2                            0x00000FA8
 170 #define  RP_VEND_CTL2_PCA_ENABLE                (1 << 7)
 171
 172 #define RP_PRIV_MISC    0x00000FE0
 173 #define  RP_PRIV_MISC_PRSNT_MAP_EP_PRSNT (0xE << 0)
 174 #define  RP_PRIV_MISC_PRSNT_MAP_EP_ABSNT (0xF << 0)
 175
 176 #define RP_LINK_CONTROL_STATUS                  0x00000090
 177 #define  RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE  0x20000000
 178 #define  RP_LINK_CONTROL_STATUS_LINKSTAT_MASK   0x3fff0000
 179
 180 enum tegra_pci_id {
 181         TEGRA20_PCIE,
 182         TEGRA30_PCIE,
 183         TEGRA124_PCIE,
 184         TEGRA210_PCIE,
 185 };
 186
 187 struct tegra_pcie_port {
 188         struct tegra_pcie *pcie;
 189
 190         struct fdt_resource regs;
 191         unsigned int num_lanes;
 192         unsigned int index;
 193
 194         struct list_head list;
 195 };
 196
 197 struct tegra_pcie_soc {
 198         unsigned int num_ports;
 199         unsigned long pads_pll_ctl;
 200         unsigned long tx_ref_sel;
 201         bool has_pex_clkreq_en;
 202         bool has_pex_bias_ctrl;
 203         bool has_cml_clk;
 204         bool has_gen2;
 205         bool force_pca_enable;
 206 };
 207
 208 struct tegra_pcie {
 209         struct pci_controller hose;
 210
 211         struct fdt_resource pads;
 212         struct fdt_resource afi;
 213         struct fdt_resource cs;
 214
 215         struct list_head ports;
 216         unsigned long xbar;
 217
 218         const struct tegra_pcie_soc *soc;
 219         struct tegra_xusb_phy *phy;
 220 };
 221
 222 static void afi_writel(struct tegra_pcie *pcie, unsigned long value,
 223                        unsigned long offset)
 224 {
 225         writel(value, pcie->afi.start + offset);
 226 }
 227
 228 static unsigned long afi_readl(struct tegra_pcie *pcie, unsigned long offset)
 229 {
 230         return readl(pcie->afi.start + offset);
 231 }
 232
 233 static void pads_writel(struct tegra_pcie *pcie, unsigned long value,
 234                         unsigned long offset)
 235 {
 236         writel(value, pcie->pads.start + offset);
 237 }
 238
 239 static unsigned long pads_readl(struct tegra_pcie *pcie, unsigned long offset)
 240 {
 241         return readl(pcie->pads.start + offset);
 242 }
 243
 244 static unsigned long rp_readl(struct tegra_pcie_port *port,
 245                               unsigned long offset)
 246 {
 247         return readl(port->regs.start + offset);
 248 }
 249
 250 static void rp_writel(struct tegra_pcie_port *port, unsigned long value,
 251                       unsigned long offset)
 252 {
 253         writel(value, port->regs.start + offset);
 254 }
 255
 256 static unsigned long tegra_pcie_conf_offset(pci_dev_t bdf, int where)
 257 {
 258         return ((where & 0xf00) << 16) | (PCI_BUS(bdf) << 16) |
 259                (PCI_DEV(bdf) << 11) | (PCI_FUNC(bdf) << 8) |
 260                (where & 0xfc);
 261 }
 262
 263 static int tegra_pcie_conf_address(struct tegra_pcie *pcie, pci_dev_t bdf,
 264                                    int where, unsigned long *address)
 265 {
 266         unsigned int bus = PCI_BUS(bdf);
 267
 268         if (bus == 0) {
 269                 unsigned int dev = PCI_DEV(bdf);
 270                 struct tegra_pcie_port *port;
 271
 272                 list_for_each_entry(port, &pcie->ports, list) {
 273                         if (port->index + 1 == dev) {
 274                                 *address = port->regs.start + (where & ~3);
 275                                 return 0;
 276                         }
 277                 }
 278         } else {
 279                 *address = pcie->cs.start + tegra_pcie_conf_offset(bdf, where);
 280                 return 0;
 281         }
 282
 283         return -EFAULT;
 284 }
 285
 286 static int pci_tegra_read_config(struct udevice *bus, pci_dev_t bdf,
 287                                  uint offset, ulong *valuep,
 288                                  enum pci_size_t size)
 289 {
 290         struct tegra_pcie *pcie = dev_get_priv(bus);
 291         unsigned long address, value;
 292         int err;
 293
 294         err = tegra_pcie_conf_address(pcie, bdf, offset, &address);
 295         if (err < 0) {
 296                 value = 0xffffffff;
 297                 goto done;
 298         }
 299
 300         value = readl(address);
 301
 302         /* fixup root port class */
 303         if (PCI_BUS(bdf) == 0) {
 304                 if (offset == PCI_CLASS_REVISION) {
 305                         value &= ~0x00ff0000;
 306                         value |= PCI_CLASS_BRIDGE_PCI << 16;
 307                 }
 308         }
 309
 310 done:
 311         *valuep = pci_conv_32_to_size(value, offset, size);
 312
 313         return 0;
 314 }
 315
 316 static int pci_tegra_write_config(struct udevice *bus, pci_dev_t bdf,
 317                                   uint offset, ulong value,
 318                                   enum pci_size_t size)
 319 {
 320         struct tegra_pcie *pcie = dev_get_priv(bus);
 321         unsigned long address;
 322         ulong old;
 323         int err;
 324
 325         err = tegra_pcie_conf_address(pcie, bdf, offset, &address);
 326         if (err < 0)
 327                 return 0;
 328
 329         old = readl(address);
 330         value = pci_conv_size_to_32(old, value, offset, size);
 331         writel(value, address);
 332
 333         return 0;
 334 }
 335
 336 static int tegra_pcie_port_parse_dt(const void *fdt, int node,
 337                                     struct tegra_pcie_port *port)
 338 {
 339         const u32 *addr;
 340         int len;
 341
 342         addr = fdt_getprop(fdt, node, "assigned-addresses", &len);
 343         if (!addr) {
 344                 error("property \"assigned-addresses\" not found");
 345                 return -FDT_ERR_NOTFOUND;
 346         }
 347
 348         port->regs.start = fdt32_to_cpu(addr[2]);
 349         port->regs.end = port->regs.start + fdt32_to_cpu(addr[4]);
 350
 351         return 0;
 352 }
 353
 354 static int tegra_pcie_get_xbar_config(const void *fdt, int node, u32 lanes,
 355                                       enum tegra_pci_id id, unsigned long *xbar)
 356 {
 357         switch (id) {
 358         case TEGRA20_PCIE:
 359                 switch (lanes) {
 360                 case 0x00000004:
 361                         debug("single-mode configuration\n");
 362                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_SINGLE;
 363                         return 0;
 364
 365                 case 0x00000202:
 366                         debug("dual-mode configuration\n");
 367                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_DUAL;
 368                         return 0;
 369                 }
 370                 break;
 371         case TEGRA30_PCIE:
 372                 switch (lanes) {
 373                 case 0x00000204:
 374                         debug("4x1, 2x1 configuration\n");
 375                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_420;
 376                         return 0;
 377
 378                 case 0x00020202:
 379                         debug("2x3 configuration\n");
 380                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_222;
 381                         return 0;
 382
 383                 case 0x00010104:
 384                         debug("4x1, 1x2 configuration\n");
 385                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_411;
 386                         return 0;
 387                 }
 388                 break;
 389         case TEGRA124_PCIE:
 390         case TEGRA210_PCIE:
 391                 switch (lanes) {
 392                 case 0x0000104:
 393                         debug("4x1, 1x1 configuration\n");
 394                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_X4_X1;
 395                         return 0;
 396
 397                 case 0x0000102:
 398                         debug("2x1, 1x1 configuration\n");
 399                         *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_X2_X1;
 400                         return 0;
 401                 }
 402                 break;
 403         default:
 404                 break;
 405         }
 406
 407         return -FDT_ERR_NOTFOUND;
 408 }
 409
 410 static int tegra_pcie_parse_port_info(const void *fdt, int node,
 411                                       unsigned int *index,
 412                                       unsigned int *lanes)
 413 {
 414         struct fdt_pci_addr addr;
 415         int err;
 416
 417         err = fdtdec_get_int(fdt, node, "nvidia,num-lanes", 0);
 418         if (err < 0) {
 419                 error("failed to parse \"nvidia,num-lanes\" property");
 420                 return err;
 421         }
 422
 423         *lanes = err;
 424
 425         err = fdtdec_get_pci_addr(fdt, node, 0, "reg", &addr);
 426         if (err < 0) {
 427                 error("failed to parse \"reg\" property");
 428                 return err;
 429         }
 430
 431         *index = PCI_DEV(addr.phys_hi) - 1;
 432
 433         return 0;
 434 }
 435
 436 int __weak tegra_pcie_board_init(void)
 437 {
 438         return 0;
 439 }
 440
 441 static int tegra_pcie_parse_dt(const void *fdt, int node, enum tegra_pci_id id,
 442                                struct tegra_pcie *pcie)
 443 {
 444         int err, subnode;
 445         u32 lanes = 0;
 446
 447         err = fdt_get_named_resource(fdt, node, "reg", "reg-names", "pads",
 448                                      &pcie->pads);
 449         if (err < 0) {
 450                 error("resource \"pads\" not found");
 451                 return err;
 452         }
 453
 454         err = fdt_get_named_resource(fdt, node, "reg", "reg-names", "afi",
 455                                      &pcie->afi);
 456         if (err < 0) {
 457                 error("resource \"afi\" not found");
 458                 return err;
 459         }
 460
 461         err = fdt_get_named_resource(fdt, node, "reg", "reg-names", "cs",
 462                                      &pcie->cs);
 463         if (err < 0) {
 464                 error("resource \"cs\" not found");
 465                 return err;
 466         }
 467
 468         err = tegra_pcie_board_init();
 469         if (err < 0) {
 470                 error("tegra_pcie_board_init() failed: err=%d", err);
 471                 return err;
 472         }
 473
 474         pcie->phy = tegra_xusb_phy_get(TEGRA_XUSB_PADCTL_PCIE);
 475         if (pcie->phy) {
 476                 err = tegra_xusb_phy_prepare(pcie->phy);
 477                 if (err < 0) {
 478                         error("failed to prepare PHY: %d", err);
 479                         return err;
 480                 }
 481         }
 482
 483         fdt_for_each_subnode(fdt, subnode, node) {
 484                 unsigned int index = 0, num_lanes = 0;
 485                 struct tegra_pcie_port *port;
 486
 487                 err = tegra_pcie_parse_port_info(fdt, subnode, &index,
 488                                                  &num_lanes);
 489                 if (err < 0) {
 490                         error("failed to obtain root port info");
 491                         continue;
 492                 }
 493
 494                 lanes |= num_lanes << (index << 3);
 495
 496                 if (!fdtdec_get_is_enabled(fdt, subnode))
 497                         continue;
 498
 499                 port = malloc(sizeof(*port));
 500                 if (!port)
 501                         continue;
 502
 503                 memset(port, 0, sizeof(*port));
 504                 port->num_lanes = num_lanes;
 505                 port->index = index;
 506
 507                 err = tegra_pcie_port_parse_dt(fdt, subnode, port);
 508                 if (err < 0) {
 509                         free(port);
 510                         continue;
 511                 }
 512
 513                 list_add_tail(&port->list, &pcie->ports);
 514                 port->pcie = pcie;
 515         }
 516
 517         err = tegra_pcie_get_xbar_config(fdt, node, lanes, id, &pcie->xbar);
 518         if (err < 0) {
 519                 error("invalid lane configuration");
 520                 return err;
 521         }
 522
 523         return 0;
 524 }
 525
 526 static int tegra_pcie_power_on(struct tegra_pcie *pcie)
 527 {
 528         const struct tegra_pcie_soc *soc = pcie->soc;
 529         unsigned long value;
 530         int err;
 531
 532         /* reset PCIEXCLK logic, AFI controller and PCIe controller */
 533         reset_set_enable(PERIPH_ID_PCIEXCLK, 1);
 534         reset_set_enable(PERIPH_ID_AFI, 1);
 535         reset_set_enable(PERIPH_ID_PCIE, 1);
 536
 537         err = tegra_powergate_power_off(TEGRA_POWERGATE_PCIE);
 538         if (err < 0) {
 539                 error("failed to power off PCIe partition: %d", err);
 540                 return err;
 541         }
 542
 543         err = tegra_powergate_sequence_power_up(TEGRA_POWERGATE_PCIE,
 544                                                 PERIPH_ID_PCIE);
 545         if (err < 0) {
 546                 error("failed to power up PCIe partition: %d", err);
 547                 return err;
 548         }
 549
 550         /* take AFI controller out of reset */
 551         reset_set_enable(PERIPH_ID_AFI, 0);
 552
 553         /* enable AFI clock */
 554         clock_enable(PERIPH_ID_AFI);
 555
 556         if (soc->has_cml_clk) {
 557                 /* enable CML clock */
 558                 value = readl(NV_PA_CLK_RST_BASE + 0x48c);
 559                 value |= (1 << 0);
 560                 value &= ~(1 << 1);
 561                 writel(value, NV_PA_CLK_RST_BASE + 0x48c);
 562         }
 563
 564         err = tegra_plle_enable();
 565         if (err < 0) {
 566                 error("failed to enable PLLE: %d\n", err);
 567                 return err;
 568         }
 569
 570         return 0;
 571 }
 572
 573 static int tegra_pcie_pll_wait(struct tegra_pcie *pcie, unsigned long timeout)
 574 {
 575         const struct tegra_pcie_soc *soc = pcie->soc;
 576         unsigned long start = get_timer(0);
 577         u32 value;
 578
 579         while (get_timer(start) < timeout) {
 580                 value = pads_readl(pcie, soc->pads_pll_ctl);
 581                 if (value & PADS_PLL_CTL_LOCKDET)
 582                         return 0;
 583         }
 584
 585         return -ETIMEDOUT;
 586 }
 587
 588 static int tegra_pcie_phy_enable(struct tegra_pcie *pcie)
 589 {
 590         const struct tegra_pcie_soc *soc = pcie->soc;
 591         u32 value;
 592         int err;
 593
 594         /* initialize internal PHY, enable up to 16 PCIe lanes */
 595         pads_writel(pcie, 0, PADS_CTL_SEL);
 596
 597         /* override IDDQ to 1 on all 4 lanes */
 598         value = pads_readl(pcie, PADS_CTL);
 599         value |= PADS_CTL_IDDQ_1L;
 600         pads_writel(pcie, value, PADS_CTL);
 601
 602         /*
 603          * Set up PHY PLL inputs select PLLE output as refclock, set TX
 604          * ref sel to div10 (not div5).
 605          */
 606         value = pads_readl(pcie, soc->pads_pll_ctl);
 607         value &= ~(PADS_PLL_CTL_REFCLK_MASK | PADS_PLL_CTL_TXCLKREF_MASK);
 608         value |= PADS_PLL_CTL_REFCLK_INTERNAL_CML | soc->tx_ref_sel;
 609         pads_writel(pcie, value, soc->pads_pll_ctl);
 610
 611         /* reset PLL */
 612         value = pads_readl(pcie, soc->pads_pll_ctl);
 613         value &= ~PADS_PLL_CTL_RST_B4SM;
 614         pads_writel(pcie, value, soc->pads_pll_ctl);
 615
 616         udelay(20);
 617
 618         /* take PLL out of reset */
 619         value = pads_readl(pcie, soc->pads_pll_ctl);
 620         value |= PADS_PLL_CTL_RST_B4SM;
 621         pads_writel(pcie, value, soc->pads_pll_ctl);
 622
 623         /* configure the reference clock driver */
 624         value = PADS_REFCLK_CFG_VALUE | (PADS_REFCLK_CFG_VALUE << 16);
 625         pads_writel(pcie, value, PADS_REFCLK_CFG0);
 626
 627         if (soc->num_ports > 2)
 628                 pads_writel(pcie, PADS_REFCLK_CFG_VALUE, PADS_REFCLK_CFG1);
 629
 630         /* wait for the PLL to lock */
 631         err = tegra_pcie_pll_wait(pcie, 500);
 632         if (err < 0) {
 633                 error("PLL failed to lock: %d", err);
 634                 return err;
 635         }
 636
 637         /* turn off IDDQ override */
 638         value = pads_readl(pcie, PADS_CTL);
 639         value &= ~PADS_CTL_IDDQ_1L;
 640         pads_writel(pcie, value, PADS_CTL);
 641
 642         /* enable TX/RX data */
 643         value = pads_readl(pcie, PADS_CTL);
 644         value |= PADS_CTL_TX_DATA_EN_1L | PADS_CTL_RX_DATA_EN_1L;
 645         pads_writel(pcie, value, PADS_CTL);
 646
 647         return 0;
 648 }
 649
 650 static int tegra_pcie_enable_controller(struct tegra_pcie *pcie)
 651 {
 652         const struct tegra_pcie_soc *soc = pcie->soc;
 653         struct tegra_pcie_port *port;
 654         u32 value;
 655         int err;
 656
 657         if (pcie->phy) {
 658                 value = afi_readl(pcie, AFI_PLLE_CONTROL);
 659                 value &= ~AFI_PLLE_CONTROL_BYPASS_PADS2PLLE_CONTROL;
 660                 value |= AFI_PLLE_CONTROL_PADS2PLLE_CONTROL_EN;
 661                 afi_writel(pcie, value, AFI_PLLE_CONTROL);
 662         }
 663
 664         if (soc->has_pex_bias_ctrl)
 665                 afi_writel(pcie, 0, AFI_PEXBIAS_CTRL_0);
 666
 667         value = afi_readl(pcie, AFI_PCIE_CONFIG);
 668         value &= ~AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_MASK;
 669         value |= AFI_PCIE_CONFIG_PCIE_DISABLE_ALL | pcie->xbar;
 670
 671         list_for_each_entry(port, &pcie->ports, list)
 672                 value &= ~AFI_PCIE_CONFIG_PCIE_DISABLE(port->index);
 673
 674         afi_writel(pcie, value, AFI_PCIE_CONFIG);
 675
 676         value = afi_readl(pcie, AFI_FUSE);
 677
 678         if (soc->has_gen2)
 679                 value &= ~AFI_FUSE_PCIE_T0_GEN2_DIS;
 680         else
 681                 value |= AFI_FUSE_PCIE_T0_GEN2_DIS;
 682
 683         afi_writel(pcie, value, AFI_FUSE);
 684
 685         if (pcie->phy)
 686                 err = tegra_xusb_phy_enable(pcie->phy);
 687         else
 688                 err = tegra_pcie_phy_enable(pcie);
 689
 690         if (err < 0) {
 691                 error("failed to power on PHY: %d\n", err);
 692                 return err;
 693         }
 694
 695         /* take the PCIEXCLK logic out of reset */
 696         reset_set_enable(PERIPH_ID_PCIEXCLK, 0);
 697
 698         /* finally enable PCIe */
 699         value = afi_readl(pcie, AFI_CONFIGURATION);
 700         value |= AFI_CONFIGURATION_EN_FPCI;
 701         afi_writel(pcie, value, AFI_CONFIGURATION);
 702
 703         /* disable all interrupts */
 704         afi_writel(pcie, 0, AFI_AFI_INTR_ENABLE);
 705         afi_writel(pcie, 0, AFI_SM_INTR_ENABLE);
 706         afi_writel(pcie, 0, AFI_INTR_MASK);
 707         afi_writel(pcie, 0, AFI_FPCI_ERROR_MASKS);
 708
 709         return 0;
 710 }
 711
 712 static int tegra_pcie_setup_translations(struct udevice *bus)
 713 {
 714         struct tegra_pcie *pcie = dev_get_priv(bus);
 715         unsigned long fpci, axi, size;
 716         struct pci_region *io, *mem, *pref;
 717         int count;
 718
 719         /* BAR 0: type 1 extended configuration space */
 720         fpci = 0xfe100000;
 721         size = fdt_resource_size(&pcie->cs);
 722         axi = pcie->cs.start;
 723
 724         afi_writel(pcie, axi, AFI_AXI_BAR0_START);
 725         afi_writel(pcie, size >> 12, AFI_AXI_BAR0_SZ);
 726         afi_writel(pcie, fpci, AFI_FPCI_BAR0);
 727
 728         count = pci_get_regions(bus, &io, &mem, &pref);
 729         if (count != 3)
 730                 return -EINVAL;
 731
 732         /* BAR 1: downstream I/O */
 733         fpci = 0xfdfc0000;
 734         size = io->size;
 735         axi = io->phys_start;
 736
 737         afi_writel(pcie, axi, AFI_AXI_BAR1_START);
 738         afi_writel(pcie, size >> 12, AFI_AXI_BAR1_SZ);
 739         afi_writel(pcie, fpci, AFI_FPCI_BAR1);
 740
 741         /* BAR 2: prefetchable memory */
 742         fpci = (((pref->phys_start >> 12) & 0x0fffffff) << 4) | 0x1;
 743         size = pref->size;
 744         axi = pref->phys_start;
 745
 746         afi_writel(pcie, axi, AFI_AXI_BAR2_START);
 747         afi_writel(pcie, size >> 12, AFI_AXI_BAR2_SZ);
 748         afi_writel(pcie, fpci, AFI_FPCI_BAR2);
 749
 750         /* BAR 3: non-prefetchable memory */
 751         fpci = (((mem->phys_start >> 12) & 0x0fffffff) << 4) | 0x1;
 752         size = mem->size;
 753         axi = mem->phys_start;
 754
 755         afi_writel(pcie, axi, AFI_AXI_BAR3_START);
 756         afi_writel(pcie, size >> 12, AFI_AXI_BAR3_SZ);
 757         afi_writel(pcie, fpci, AFI_FPCI_BAR3);
 758
 759         /* NULL out the remaining BARs as they are not used */
 760         afi_writel(pcie, 0, AFI_AXI_BAR4_START);
 761         afi_writel(pcie, 0, AFI_AXI_BAR4_SZ);
 762         afi_writel(pcie, 0, AFI_FPCI_BAR4);
 763
 764         afi_writel(pcie, 0, AFI_AXI_BAR5_START);
 765         afi_writel(pcie, 0, AFI_AXI_BAR5_SZ);
 766         afi_writel(pcie, 0, AFI_FPCI_BAR5);
 767
 768         /* map all upstream transactions as uncached */
 769         afi_writel(pcie, NV_PA_SDRAM_BASE, AFI_CACHE_BAR0_ST);
 770         afi_writel(pcie, 0, AFI_CACHE_BAR0_SZ);
 771         afi_writel(pcie, 0, AFI_CACHE_BAR1_ST);
 772         afi_writel(pcie, 0, AFI_CACHE_BAR1_SZ);
 773
 774         /* MSI translations are setup only when needed */
 775         afi_writel(pcie, 0, AFI_MSI_FPCI_BAR_ST);
 776         afi_writel(pcie, 0, AFI_MSI_BAR_SZ);
 777         afi_writel(pcie, 0, AFI_MSI_AXI_BAR_ST);
 778         afi_writel(pcie, 0, AFI_MSI_BAR_SZ);
 779
 780         return 0;
 781 }
 782
 783 static unsigned long tegra_pcie_port_get_pex_ctrl(struct tegra_pcie_port *port)
 784 {
 785         unsigned long ret = 0;
 786
 787         switch (port->index) {
 788         case 0:
 789                 ret = AFI_PEX0_CTRL;
 790                 break;
 791
 792         case 1:
 793                 ret = AFI_PEX1_CTRL;
 794                 break;
 795
 796         case 2:
 797                 ret = AFI_PEX2_CTRL;
 798                 break;
 799         }
 800
 801         return ret;
 802 }
 803
 804 static void tegra_pcie_port_reset(struct tegra_pcie_port *port)
 805 {
 806         unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
 807         unsigned long value;
 808
 809         /* pulse reset signel */
 810         value = afi_readl(port->pcie, ctrl);
 811         value &= ~AFI_PEX_CTRL_RST;
 812         afi_writel(port->pcie, value, ctrl);
 813
 814         udelay(2000);
 815
 816         value = afi_readl(port->pcie, ctrl);
 817         value |= AFI_PEX_CTRL_RST;
 818         afi_writel(port->pcie, value, ctrl);
 819 }
 820
 821 static void tegra_pcie_port_enable(struct tegra_pcie_port *port)
 822 {
 823         const struct tegra_pcie_soc *soc = port->pcie->soc;
 824         unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
 825         unsigned long value;
 826
 827         /* enable reference clock */
 828         value = afi_readl(port->pcie, ctrl);
 829         value |= AFI_PEX_CTRL_REFCLK_EN;
 830
 831         if (port->pcie->soc->has_pex_clkreq_en)
 832                 value |= AFI_PEX_CTRL_CLKREQ_EN;
 833
 834         value |= AFI_PEX_CTRL_OVERRIDE_EN;
 835
 836         afi_writel(port->pcie, value, ctrl);
 837
 838         tegra_pcie_port_reset(port);
 839
 840         if (soc->force_pca_enable) {
 841                 value = rp_readl(port, RP_VEND_CTL2);
 842                 value |= RP_VEND_CTL2_PCA_ENABLE;
 843                 rp_writel(port, value, RP_VEND_CTL2);
 844         }
 845 }
 846
 847 static bool tegra_pcie_port_check_link(struct tegra_pcie_port *port)
 848 {
 849         unsigned int retries = 3;
 850         unsigned long value;
 851
 852         value = rp_readl(port, RP_PRIV_MISC);
 853         value &= ~RP_PRIV_MISC_PRSNT_MAP_EP_ABSNT;
 854         value |= RP_PRIV_MISC_PRSNT_MAP_EP_PRSNT;
 855         rp_writel(port, value, RP_PRIV_MISC);
 856
 857         do {
 858                 unsigned int timeout = 200;
 859
 860                 do {
 861                         value = rp_readl(port, RP_VEND_XP);
 862                         if (value & RP_VEND_XP_DL_UP)
 863                                 break;
 864
 865                         udelay(2000);
 866                 } while (--timeout);
 867
 868                 if (!timeout) {
 869                         debug("link %u down, retrying\n", port->index);
 870                         goto retry;
 871                 }
 872
 873                 timeout = 200;
 874
 875                 do {
 876                         value = rp_readl(port, RP_LINK_CONTROL_STATUS);
 877                         if (value & RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE)
 878                                 return true;
 879
 880                         udelay(2000);
 881                 } while (--timeout);
 882
 883 retry:
 884                 tegra_pcie_port_reset(port);
 885         } while (--retries);
 886
 887         return false;
 888 }
 889
 890 static void tegra_pcie_port_disable(struct tegra_pcie_port *port)
 891 {
 892         unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
 893         unsigned long value;
 894
 895         /* assert port reset */
 896         value = afi_readl(port->pcie, ctrl);
 897         value &= ~AFI_PEX_CTRL_RST;
 898         afi_writel(port->pcie, value, ctrl);
 899
 900         /* disable reference clock */
 901         value = afi_readl(port->pcie, ctrl);
 902         value &= ~AFI_PEX_CTRL_REFCLK_EN;
 903         afi_writel(port->pcie, value, ctrl);
 904 }
 905
 906 static void tegra_pcie_port_free(struct tegra_pcie_port *port)
 907 {
 908         list_del(&port->list);
 909         free(port);
 910 }
 911
 912 static int tegra_pcie_enable(struct tegra_pcie *pcie)
 913 {
 914         struct tegra_pcie_port *port, *tmp;
 915
 916         list_for_each_entry_safe(port, tmp, &pcie->ports, list) {
 917                 debug("probing port %u, using %u lanes\n", port->index,
 918                       port->num_lanes);
 919
 920                 tegra_pcie_port_enable(port);
 921
 922                 if (tegra_pcie_port_check_link(port))
 923                         continue;
 924
 925                 debug("link %u down, ignoring\n", port->index);
 926
 927                 tegra_pcie_port_disable(port);
 928                 tegra_pcie_port_free(port);
 929         }
 930
 931         return 0;
 932 }
 933
 934 static const struct tegra_pcie_soc pci_tegra_soc[] = {
 935         [TEGRA20_PCIE] = {
 936                 .num_ports = 2,
 937                 .pads_pll_ctl = PADS_PLL_CTL_TEGRA20,
 938                 .tx_ref_sel = PADS_PLL_CTL_TXCLKREF_DIV10,
 939                 .has_pex_clkreq_en = false,
 940                 .has_pex_bias_ctrl = false,
 941                 .has_cml_clk = false,
 942                 .has_gen2 = false,
 943         },
 944         [TEGRA30_PCIE] = {
 945                 .num_ports = 3,
 946                 .pads_pll_ctl = PADS_PLL_CTL_TEGRA30,
 947                 .tx_ref_sel = PADS_PLL_CTL_TXCLKREF_BUF_EN,
 948                 .has_pex_clkreq_en = true,
 949                 .has_pex_bias_ctrl = true,
 950                 .has_cml_clk = true,
 951                 .has_gen2 = false,
 952         },
 953         [TEGRA124_PCIE] = {
 954                 .num_ports = 2,
 955                 .pads_pll_ctl = PADS_PLL_CTL_TEGRA30,
 956                 .tx_ref_sel = PADS_PLL_CTL_TXCLKREF_BUF_EN,
 957                 .has_pex_clkreq_en = true,
 958                 .has_pex_bias_ctrl = true,
 959                 .has_cml_clk = true,
 960                 .has_gen2 = true,
 961         },
 962         [TEGRA210_PCIE] = {
 963                 .num_ports = 2,
 964                 .pads_pll_ctl = PADS_PLL_CTL_TEGRA30,
 965                 .tx_ref_sel = PADS_PLL_CTL_TXCLKREF_BUF_EN,
 966                 .has_pex_clkreq_en = true,
 967                 .has_pex_bias_ctrl = true,
 968                 .has_cml_clk = true,
 969                 .has_gen2 = true,
 970                 .force_pca_enable = true,
 971         }
 972 };
 973
 974 static int pci_tegra_ofdata_to_platdata(struct udevice *dev)
 975 {
 976         struct tegra_pcie *pcie = dev_get_priv(dev);
 977         enum tegra_pci_id id;
 978
 979         id = dev_get_driver_data(dev);
 980         pcie->soc = &pci_tegra_soc[id];
 981
 982         INIT_LIST_HEAD(&pcie->ports);
 983
 984         if (tegra_pcie_parse_dt(gd->fdt_blob, dev->of_offset, id, pcie))
 985                 return -EINVAL;
 986
 987         return 0;
 988 }
 989
 990 static int pci_tegra_probe(struct udevice *dev)
 991 {
 992         struct tegra_pcie *pcie = dev_get_priv(dev);
 993         int err;
 994
 995         err = tegra_pcie_power_on(pcie);
 996         if (err < 0) {
 997                 error("failed to power on");
 998                 return err;
 999         }
1000
1001         err = tegra_pcie_enable_controller(pcie);
1002         if (err < 0) {
1003                 error("failed to enable controller");
1004                 return err;
1005         }
1006
1007         err = tegra_pcie_setup_translations(dev);
1008         if (err < 0) {
1009                 error("failed to decode ranges");
1010                 return err;
1011         }
1012
1013         err = tegra_pcie_enable(pcie);
1014         if (err < 0) {
1015                 error("failed to enable PCIe");
1016                 return err;
1017         }
1018
1019         return 0;
1020 }
1021
1022 static const struct dm_pci_ops pci_tegra_ops = {
1023         .read_config    = pci_tegra_read_config,
1024         .write_config   = pci_tegra_write_config,
1025 };
1026
1027 static const struct udevice_id pci_tegra_ids[] = {
1028         { .compatible = "nvidia,tegra20-pcie", .data = TEGRA20_PCIE },
1029         { .compatible = "nvidia,tegra30-pcie", .data = TEGRA30_PCIE },
1030         { .compatible = "nvidia,tegra124-pcie", .data = TEGRA124_PCIE },
1031         { .compatible = "nvidia,tegra210-pcie", .data = TEGRA210_PCIE },
1032         { }
1033 };
1034
1035 U_BOOT_DRIVER(pci_tegra) = {
1036         .name   = "pci_tegra",
1037         .id     = UCLASS_PCI,
1038         .of_match = pci_tegra_ids,
1039         .ops    = &pci_tegra_ops,
1040         .ofdata_to_platdata = pci_tegra_ofdata_to_platdata,
1041         .probe  = pci_tegra_probe,
1042         .priv_auto_alloc_size = sizeof(struct tegra_pcie),
1043 };
1044
1045 int pci_skip_dev(struct pci_controller *hose, pci_dev_t dev)
1046 {
1047         if (PCI_BUS(dev) != 0 && PCI_DEV(dev) > 0)
1048                 return 1;
1049
1050         return 0;
1051 }