drivers/pci/pcie_imx.c

   1 /*
   2  * Freescale i.MX6 PCI Express Root-Complex driver
   3  *
   4  * Copyright (C) 2013 Marek Vasut <marex@denx.de>
   5  *
   6  * Based on upstream Linux kernel driver:
   7  * pci-imx6.c:          Sean Cross <xobs@kosagi.com>
   8  * pcie-designware.c:   Jingoo Han <jg1.han@samsung.com>
   9  *
  10  * SPDX-License-Identifier:     GPL-2.0
  11  */
  12
  13 #include <common.h>
  14 #include <pci.h>
  15 #include <asm/arch/clock.h>
  16 #include <asm/arch/iomux.h>
  17 #include <asm/arch/crm_regs.h>
  18 #include <asm/gpio.h>
  19 #include <asm/io.h>
  20 #include <linux/sizes.h>
  21 #include <errno.h>
  22
  23 #define PCI_ACCESS_READ  0
  24 #define PCI_ACCESS_WRITE 1
  25
  26 #ifdef CONFIG_MX6SX
  27 #define MX6_DBI_ADDR    0x08ffc000
  28 #define MX6_IO_ADDR     0x08000000
  29 #define MX6_MEM_ADDR    0x08100000
  30 #define MX6_ROOT_ADDR   0x08f00000
  31 #else
  32 #define MX6_DBI_ADDR    0x01ffc000
  33 #define MX6_IO_ADDR     0x01000000
  34 #define MX6_MEM_ADDR    0x01100000
  35 #define MX6_ROOT_ADDR   0x01f00000
  36 #endif
  37 #define MX6_DBI_SIZE    0x4000
  38 #define MX6_IO_SIZE     0x100000
  39 #define MX6_MEM_SIZE    0xe00000
  40 #define MX6_ROOT_SIZE   0xfc000
  41
  42 /* PCIe Port Logic registers (memory-mapped) */
  43 #define PL_OFFSET 0x700
  44 #define PCIE_PHY_DEBUG_R0 (PL_OFFSET + 0x28)
  45 #define PCIE_PHY_DEBUG_R1 (PL_OFFSET + 0x2c)
  46 #define PCIE_PHY_DEBUG_R1_LINK_UP               (1 << 4)
  47 #define PCIE_PHY_DEBUG_R1_LINK_IN_TRAINING      (1 << 29)
  48
  49 #define PCIE_PHY_CTRL (PL_OFFSET + 0x114)
  50 #define PCIE_PHY_CTRL_DATA_LOC 0
  51 #define PCIE_PHY_CTRL_CAP_ADR_LOC 16
  52 #define PCIE_PHY_CTRL_CAP_DAT_LOC 17
  53 #define PCIE_PHY_CTRL_WR_LOC 18
  54 #define PCIE_PHY_CTRL_RD_LOC 19
  55
  56 #define PCIE_PHY_STAT (PL_OFFSET + 0x110)
  57 #define PCIE_PHY_STAT_DATA_LOC 0
  58 #define PCIE_PHY_STAT_ACK_LOC 16
  59
  60 /* PHY registers (not memory-mapped) */
  61 #define PCIE_PHY_RX_ASIC_OUT 0x100D
  62
  63 #define PHY_RX_OVRD_IN_LO 0x1005
  64 #define PHY_RX_OVRD_IN_LO_RX_DATA_EN (1 << 5)
  65 #define PHY_RX_OVRD_IN_LO_RX_PLL_EN (1 << 3)
  66
  67 #define PCIE_PHY_PUP_REQ                (1 << 7)
  68
  69 /* iATU registers */
  70 #define PCIE_ATU_VIEWPORT               0x900
  71 #define PCIE_ATU_REGION_INBOUND         (0x1 << 31)
  72 #define PCIE_ATU_REGION_OUTBOUND        (0x0 << 31)
  73 #define PCIE_ATU_REGION_INDEX1          (0x1 << 0)
  74 #define PCIE_ATU_REGION_INDEX0          (0x0 << 0)
  75 #define PCIE_ATU_CR1                    0x904
  76 #define PCIE_ATU_TYPE_MEM               (0x0 << 0)
  77 #define PCIE_ATU_TYPE_IO                (0x2 << 0)
  78 #define PCIE_ATU_TYPE_CFG0              (0x4 << 0)
  79 #define PCIE_ATU_TYPE_CFG1              (0x5 << 0)
  80 #define PCIE_ATU_CR2                    0x908
  81 #define PCIE_ATU_ENABLE                 (0x1 << 31)
  82 #define PCIE_ATU_BAR_MODE_ENABLE        (0x1 << 30)
  83 #define PCIE_ATU_LOWER_BASE             0x90C
  84 #define PCIE_ATU_UPPER_BASE             0x910
  85 #define PCIE_ATU_LIMIT                  0x914
  86 #define PCIE_ATU_LOWER_TARGET           0x918
  87 #define PCIE_ATU_BUS(x)                 (((x) & 0xff) << 24)
  88 #define PCIE_ATU_DEV(x)                 (((x) & 0x1f) << 19)
  89 #define PCIE_ATU_FUNC(x)                (((x) & 0x7) << 16)
  90 #define PCIE_ATU_UPPER_TARGET           0x91C
  91
  92 /*
  93  * PHY access functions
  94  */
  95 static int pcie_phy_poll_ack(void __iomem *dbi_base, int exp_val)
  96 {
  97         u32 val;
  98         u32 max_iterations = 10;
  99         u32 wait_counter = 0;
 100
 101         do {
 102                 val = readl(dbi_base + PCIE_PHY_STAT);
 103                 val = (val >> PCIE_PHY_STAT_ACK_LOC) & 0x1;
 104                 wait_counter++;
 105
 106                 if (val == exp_val)
 107                         return 0;
 108
 109                 udelay(1);
 110         } while (wait_counter < max_iterations);
 111
 112         return -ETIMEDOUT;
 113 }
 114
 115 static int pcie_phy_wait_ack(void __iomem *dbi_base, int addr)
 116 {
 117         u32 val;
 118         int ret;
 119
 120         val = addr << PCIE_PHY_CTRL_DATA_LOC;
 121         writel(val, dbi_base + PCIE_PHY_CTRL);
 122
 123         val |= (0x1 << PCIE_PHY_CTRL_CAP_ADR_LOC);
 124         writel(val, dbi_base + PCIE_PHY_CTRL);
 125
 126         ret = pcie_phy_poll_ack(dbi_base, 1);
 127         if (ret)
 128                 return ret;
 129
 130         val = addr << PCIE_PHY_CTRL_DATA_LOC;
 131         writel(val, dbi_base + PCIE_PHY_CTRL);
 132
 133         ret = pcie_phy_poll_ack(dbi_base, 0);
 134         if (ret)
 135                 return ret;
 136
 137         return 0;
 138 }
 139
 140 /* Read from the 16-bit PCIe PHY control registers (not memory-mapped) */
 141 static int pcie_phy_read(void __iomem *dbi_base, int addr , int *data)
 142 {
 143         u32 val, phy_ctl;
 144         int ret;
 145
 146         ret = pcie_phy_wait_ack(dbi_base, addr);
 147         if (ret)
 148                 return ret;
 149
 150         /* assert Read signal */
 151         phy_ctl = 0x1 << PCIE_PHY_CTRL_RD_LOC;
 152         writel(phy_ctl, dbi_base + PCIE_PHY_CTRL);
 153
 154         ret = pcie_phy_poll_ack(dbi_base, 1);
 155         if (ret)
 156                 return ret;
 157
 158         val = readl(dbi_base + PCIE_PHY_STAT);
 159         *data = val & 0xffff;
 160
 161         /* deassert Read signal */
 162         writel(0x00, dbi_base + PCIE_PHY_CTRL);
 163
 164         ret = pcie_phy_poll_ack(dbi_base, 0);
 165         if (ret)
 166                 return ret;
 167
 168         return 0;
 169 }
 170
 171 static int pcie_phy_write(void __iomem *dbi_base, int addr, int data)
 172 {
 173         u32 var;
 174         int ret;
 175
 176         /* write addr */
 177         /* cap addr */
 178         ret = pcie_phy_wait_ack(dbi_base, addr);
 179         if (ret)
 180                 return ret;
 181
 182         var = data << PCIE_PHY_CTRL_DATA_LOC;
 183         writel(var, dbi_base + PCIE_PHY_CTRL);
 184
 185         /* capture data */
 186         var |= (0x1 << PCIE_PHY_CTRL_CAP_DAT_LOC);
 187         writel(var, dbi_base + PCIE_PHY_CTRL);
 188
 189         ret = pcie_phy_poll_ack(dbi_base, 1);
 190         if (ret)
 191                 return ret;
 192
 193         /* deassert cap data */
 194         var = data << PCIE_PHY_CTRL_DATA_LOC;
 195         writel(var, dbi_base + PCIE_PHY_CTRL);
 196
 197         /* wait for ack de-assertion */
 198         ret = pcie_phy_poll_ack(dbi_base, 0);
 199         if (ret)
 200                 return ret;
 201
 202         /* assert wr signal */
 203         var = 0x1 << PCIE_PHY_CTRL_WR_LOC;
 204         writel(var, dbi_base + PCIE_PHY_CTRL);
 205
 206         /* wait for ack */
 207         ret = pcie_phy_poll_ack(dbi_base, 1);
 208         if (ret)
 209                 return ret;
 210
 211         /* deassert wr signal */
 212         var = data << PCIE_PHY_CTRL_DATA_LOC;
 213         writel(var, dbi_base + PCIE_PHY_CTRL);
 214
 215         /* wait for ack de-assertion */
 216         ret = pcie_phy_poll_ack(dbi_base, 0);
 217         if (ret)
 218                 return ret;
 219
 220         writel(0x0, dbi_base + PCIE_PHY_CTRL);
 221
 222         return 0;
 223 }
 224
 225 static int imx6_pcie_link_up(void)
 226 {
 227         u32 rc, ltssm;
 228         int rx_valid, temp;
 229
 230         /* link is debug bit 36, debug register 1 starts at bit 32 */
 231         rc = readl(MX6_DBI_ADDR + PCIE_PHY_DEBUG_R1);
 232         if ((rc & PCIE_PHY_DEBUG_R1_LINK_UP) &&
 233             !(rc & PCIE_PHY_DEBUG_R1_LINK_IN_TRAINING))
 234                 return -EAGAIN;
 235
 236         /*
 237          * From L0, initiate MAC entry to gen2 if EP/RC supports gen2.
 238          * Wait 2ms (LTSSM timeout is 24ms, PHY lock is ~5us in gen2).
 239          * If (MAC/LTSSM.state == Recovery.RcvrLock)
 240          * && (PHY/rx_valid==0) then pulse PHY/rx_reset. Transition
 241          * to gen2 is stuck
 242          */
 243         pcie_phy_read((void *)MX6_DBI_ADDR, PCIE_PHY_RX_ASIC_OUT, &rx_valid);
 244         ltssm = readl(MX6_DBI_ADDR + PCIE_PHY_DEBUG_R0) & 0x3F;
 245
 246         if (rx_valid & 0x01)
 247                 return 0;
 248
 249         if (ltssm != 0x0d)
 250                 return 0;
 251
 252         printf("transition to gen2 is stuck, reset PHY!\n");
 253
 254         pcie_phy_read((void *)MX6_DBI_ADDR, PHY_RX_OVRD_IN_LO, &temp);
 255         temp |= (PHY_RX_OVRD_IN_LO_RX_DATA_EN | PHY_RX_OVRD_IN_LO_RX_PLL_EN);
 256         pcie_phy_write((void *)MX6_DBI_ADDR, PHY_RX_OVRD_IN_LO, temp);
 257
 258         udelay(3000);
 259
 260         pcie_phy_read((void *)MX6_DBI_ADDR, PHY_RX_OVRD_IN_LO, &temp);
 261         temp &= ~(PHY_RX_OVRD_IN_LO_RX_DATA_EN | PHY_RX_OVRD_IN_LO_RX_PLL_EN);
 262         pcie_phy_write((void *)MX6_DBI_ADDR, PHY_RX_OVRD_IN_LO, temp);
 263
 264         return 0;
 265 }
 266
 267 /*
 268  * iATU region setup
 269  */
 270 static int imx_pcie_regions_setup(void)
 271 {
 272         /*
 273          * i.MX6 defines 16MB in the AXI address map for PCIe.
 274          *
 275          * That address space excepted the pcie registers is
 276          * split and defined into different regions by iATU,
 277          * with sizes and offsets as follows:
 278          *
 279          * 0x0100_0000 --- 0x010F_FFFF 1MB IORESOURCE_IO
 280          * 0x0110_0000 --- 0x01EF_FFFF 14MB IORESOURCE_MEM
 281          * 0x01F0_0000 --- 0x01FF_FFFF 1MB Cfg + Registers
 282          */
 283
 284         /* CMD reg:I/O space, MEM space, and Bus Master Enable */
 285         setbits_le32(MX6_DBI_ADDR | PCI_COMMAND,
 286                      PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
 287
 288         /* Set the CLASS_REV of RC CFG header to PCI_CLASS_BRIDGE_PCI */
 289         setbits_le32(MX6_DBI_ADDR + PCI_CLASS_REVISION,
 290                      PCI_CLASS_BRIDGE_PCI << 16);
 291
 292         /* Region #0 is used for Outbound CFG space access. */
 293         writel(0, MX6_DBI_ADDR + PCIE_ATU_VIEWPORT);
 294
 295         writel(MX6_ROOT_ADDR, MX6_DBI_ADDR + PCIE_ATU_LOWER_BASE);
 296         writel(0, MX6_DBI_ADDR + PCIE_ATU_UPPER_BASE);
 297         writel(MX6_ROOT_ADDR + MX6_ROOT_SIZE, MX6_DBI_ADDR + PCIE_ATU_LIMIT);
 298
 299         writel(0, MX6_DBI_ADDR + PCIE_ATU_LOWER_TARGET);
 300         writel(0, MX6_DBI_ADDR + PCIE_ATU_UPPER_TARGET);
 301         writel(PCIE_ATU_TYPE_CFG0, MX6_DBI_ADDR + PCIE_ATU_CR1);
 302         writel(PCIE_ATU_ENABLE, MX6_DBI_ADDR + PCIE_ATU_CR2);
 303
 304         return 0;
 305 }
 306
 307 /*
 308  * PCI Express accessors
 309  */
 310 static uint32_t get_bus_address(pci_dev_t d, int where)
 311 {
 312         uint32_t va_address;
 313
 314         /* Reconfigure Region #0 */
 315         writel(0, MX6_DBI_ADDR + PCIE_ATU_VIEWPORT);
 316
 317         if (PCI_BUS(d) < 2)
 318                 writel(PCIE_ATU_TYPE_CFG0, MX6_DBI_ADDR + PCIE_ATU_CR1);
 319         else
 320                 writel(PCIE_ATU_TYPE_CFG1, MX6_DBI_ADDR + PCIE_ATU_CR1);
 321
 322         if (PCI_BUS(d) == 0) {
 323                 va_address = MX6_DBI_ADDR;
 324         } else {
 325                 writel(d << 8, MX6_DBI_ADDR + PCIE_ATU_LOWER_TARGET);
 326                 va_address = MX6_IO_ADDR + SZ_16M - SZ_1M;
 327         }
 328
 329         va_address += (where & ~0x3);
 330
 331         return va_address;
 332 }
 333
 334 static int imx_pcie_addr_valid(pci_dev_t d)
 335 {
 336         if ((PCI_BUS(d) == 0) && (PCI_DEV(d) > 1))
 337                 return -EINVAL;
 338         if ((PCI_BUS(d) == 1) && (PCI_DEV(d) > 0))
 339                 return -EINVAL;
 340         return 0;
 341 }
 342
 343 /*
 344  * Replace the original ARM DABT handler with a simple jump-back one.
 345  *
 346  * The problem here is that if we have a PCIe bridge attached to this PCIe
 347  * controller, but no PCIe device is connected to the bridges' downstream
 348  * port, the attempt to read/write from/to the config space will produce
 349  * a DABT. This is a behavior of the controller and can not be disabled
 350  * unfortuatelly.
 351  *
 352  * To work around the problem, we backup the current DABT handler address
 353  * and replace it with our own DABT handler, which only bounces right back
 354  * into the code.
 355  */
 356 static void imx_pcie_fix_dabt_handler(bool set)
 357 {
 358         extern uint32_t *_data_abort;
 359         uint32_t *data_abort_addr = (uint32_t *)&_data_abort;
 360
 361         static const uint32_t data_abort_bounce_handler = 0xe25ef004;
 362         uint32_t data_abort_bounce_addr = (uint32_t)&data_abort_bounce_handler;
 363
 364         static uint32_t data_abort_backup;
 365
 366         if (set) {
 367                 data_abort_backup = *data_abort_addr;
 368                 *data_abort_addr = data_abort_bounce_addr;
 369         } else {
 370                 *data_abort_addr = data_abort_backup;
 371         }
 372 }
 373
 374 static int imx_pcie_read_config(struct pci_controller *hose, pci_dev_t d,
 375                                 int where, u32 *val)
 376 {
 377         uint32_t va_address;
 378         int ret;
 379
 380         ret = imx_pcie_addr_valid(d);
 381         if (ret) {
 382                 *val = 0xffffffff;
 383                 return ret;
 384         }
 385
 386         va_address = get_bus_address(d, where);
 387
 388         /*
 389          * Read the PCIe config space. We must replace the DABT handler
 390          * here in case we got data abort from the PCIe controller, see
 391          * imx_pcie_fix_dabt_handler() description. Note that writing the
 392          * "val" with valid value is also imperative here as in case we
 393          * did got DABT, the val would contain random value.
 394          */
 395         imx_pcie_fix_dabt_handler(true);
 396         writel(0xffffffff, val);
 397         *val = readl(va_address);
 398         imx_pcie_fix_dabt_handler(false);
 399
 400         return 0;
 401 }
 402
 403 static int imx_pcie_write_config(struct pci_controller *hose, pci_dev_t d,
 404                         int where, u32 val)
 405 {
 406         uint32_t va_address = 0;
 407         int ret;
 408
 409         ret = imx_pcie_addr_valid(d);
 410         if (ret)
 411                 return ret;
 412
 413         va_address = get_bus_address(d, where);
 414
 415         /*
 416          * Write the PCIe config space. We must replace the DABT handler
 417          * here in case we got data abort from the PCIe controller, see
 418          * imx_pcie_fix_dabt_handler() description.
 419          */
 420         imx_pcie_fix_dabt_handler(true);
 421         writel(val, va_address);
 422         imx_pcie_fix_dabt_handler(false);
 423
 424         return 0;
 425 }
 426
 427 /*
 428  * Initial bus setup
 429  */
 430 static int imx6_pcie_assert_core_reset(void)
 431 {
 432         struct iomuxc *iomuxc_regs = (struct iomuxc *)IOMUXC_BASE_ADDR;
 433 #if defined(CONFIG_MX6SX)
 434         struct gpc *gpc_regs = (struct gpc *)GPC_BASE_ADDR;
 435
 436         /* SSP_EN is not used on MX6SX anymore */
 437         setbits_le32(&iomuxc_regs->gpr[12], IOMUXC_GPR12_TEST_POWERDOWN);
 438         /* Force PCIe PHY reset */
 439         setbits_le32(&iomuxc_regs->gpr[5], IOMUXC_GPR5_PCIE_BTNRST);
 440         /* Power up PCIe PHY */
 441         setbits_le32(&gpc_regs->cntr, PCIE_PHY_PUP_REQ);
 442 #else
 443         setbits_le32(&iomuxc_regs->gpr[1], IOMUXC_GPR1_TEST_POWERDOWN);
 444         clrbits_le32(&iomuxc_regs->gpr[1], IOMUXC_GPR1_REF_SSP_EN);
 445 #endif
 446
 447         return 0;
 448 }
 449
 450 static int imx6_pcie_init_phy(void)
 451 {
 452         struct iomuxc *iomuxc_regs = (struct iomuxc *)IOMUXC_BASE_ADDR;
 453
 454         clrbits_le32(&iomuxc_regs->gpr[12], IOMUXC_GPR12_APPS_LTSSM_ENABLE);
 455
 456         clrsetbits_le32(&iomuxc_regs->gpr[12],
 457                         IOMUXC_GPR12_DEVICE_TYPE_MASK,
 458                         IOMUXC_GPR12_DEVICE_TYPE_RC);
 459         clrsetbits_le32(&iomuxc_regs->gpr[12],
 460                         IOMUXC_GPR12_LOS_LEVEL_MASK,
 461                         IOMUXC_GPR12_LOS_LEVEL_9);
 462
 463 #ifdef CONFIG_MX6SX
 464         clrsetbits_le32(&iomuxc_regs->gpr[12],
 465                         IOMUXC_GPR12_RX_EQ_MASK,
 466                         IOMUXC_GPR12_RX_EQ_2);
 467 #endif
 468
 469         writel((0x0 << IOMUXC_GPR8_PCS_TX_DEEMPH_GEN1_OFFSET) |
 470                (0x0 << IOMUXC_GPR8_PCS_TX_DEEMPH_GEN2_3P5DB_OFFSET) |
 471                (20 << IOMUXC_GPR8_PCS_TX_DEEMPH_GEN2_6DB_OFFSET) |
 472                (127 << IOMUXC_GPR8_PCS_TX_SWING_FULL_OFFSET) |
 473                (127 << IOMUXC_GPR8_PCS_TX_SWING_LOW_OFFSET),
 474                &iomuxc_regs->gpr[8]);
 475
 476         return 0;
 477 }
 478
 479 __weak int imx6_pcie_toggle_power(void)
 480 {
 481 #ifdef CONFIG_PCIE_IMX_POWER_GPIO
 482         gpio_direction_output(CONFIG_PCIE_IMX_POWER_GPIO, 0);
 483         mdelay(20);
 484         gpio_set_value(CONFIG_PCIE_IMX_POWER_GPIO, 1);
 485         mdelay(20);
 486 #endif
 487         return 0;
 488 }
 489
 490 __weak int imx6_pcie_toggle_reset(void)
 491 {
 492         /*
 493          * See 'PCI EXPRESS BASE SPECIFICATION, REV 3.0, SECTION 6.6.1'
 494          * for detailed understanding of the PCIe CR reset logic.
 495          *
 496          * The PCIe #PERST reset line _MUST_ be connected, otherwise your
 497          * design does not conform to the specification. You must wait at
 498          * least 20 mS after de-asserting the #PERST so the EP device can
 499          * do self-initialisation.
 500          *
 501          * In case your #PERST pin is connected to a plain GPIO pin of the
 502          * CPU, you can define CONFIG_PCIE_IMX_PERST_GPIO in your board's
 503          * configuration file and the condition below will handle the rest
 504          * of the reset toggling.
 505          *
 506          * In case your #PERST toggling logic is more complex, for example
 507          * connected via CPLD or somesuch, you can override this function
 508          * in your board file and implement reset logic as needed. You must
 509          * not forget to wait at least 20 mS after de-asserting #PERST in
 510          * this case either though.
 511          *
 512          * In case your #PERST line of the PCIe EP device is not connected
 513          * at all, your design is broken and you should fix your design,
 514          * otherwise you will observe problems like for example the link
 515          * not coming up after rebooting the system back from running Linux
 516          * that uses the PCIe as well OR the PCIe link might not come up in
 517          * Linux at all in the first place since it's in some non-reset
 518          * state due to being previously used in U-Boot.
 519          */
 520 #ifdef CONFIG_PCIE_IMX_PERST_GPIO
 521         gpio_direction_output(CONFIG_PCIE_IMX_PERST_GPIO, 0);
 522         mdelay(20);
 523         gpio_set_value(CONFIG_PCIE_IMX_PERST_GPIO, 1);
 524         mdelay(20);
 525 #else
 526         puts("WARNING: Make sure the PCIe #PERST line is connected!\n");
 527 #endif
 528         return 0;
 529 }
 530
 531 static int imx6_pcie_deassert_core_reset(void)
 532 {
 533         struct iomuxc *iomuxc_regs = (struct iomuxc *)IOMUXC_BASE_ADDR;
 534
 535         imx6_pcie_toggle_power();
 536
 537         enable_pcie_clock();
 538
 539         /*
 540          * Wait for the clock to settle a bit, when the clock are sourced
 541          * from the CPU, we need about 30mS to settle.
 542          */
 543         mdelay(50);
 544
 545 #if defined(CONFIG_MX6SX)
 546         /* SSP_EN is not used on MX6SX anymore */
 547         clrbits_le32(&iomuxc_regs->gpr[12], IOMUXC_GPR12_TEST_POWERDOWN);
 548         /* Clear PCIe PHY reset bit */
 549         clrbits_le32(&iomuxc_regs->gpr[5], IOMUXC_GPR5_PCIE_BTNRST);
 550 #else
 551         /* Enable PCIe */
 552         clrbits_le32(&iomuxc_regs->gpr[1], IOMUXC_GPR1_TEST_POWERDOWN);
 553         setbits_le32(&iomuxc_regs->gpr[1], IOMUXC_GPR1_REF_SSP_EN);
 554 #endif
 555
 556         imx6_pcie_toggle_reset();
 557
 558         return 0;
 559 }
 560
 561 static int imx_pcie_link_up(void)
 562 {
 563         struct iomuxc *iomuxc_regs = (struct iomuxc *)IOMUXC_BASE_ADDR;
 564         uint32_t tmp;
 565         int count = 0;
 566
 567         imx6_pcie_assert_core_reset();
 568         imx6_pcie_init_phy();
 569         imx6_pcie_deassert_core_reset();
 570
 571         imx_pcie_regions_setup();
 572
 573         /*
 574          * FIXME: Force the PCIe RC to Gen1 operation
 575          * The RC must be forced into Gen1 mode before bringing the link
 576          * up, otherwise no downstream devices are detected. After the
 577          * link is up, a managed Gen1->Gen2 transition can be initiated.
 578          */
 579         tmp = readl(MX6_DBI_ADDR + 0x7c);
 580         tmp &= ~0xf;
 581         tmp |= 0x1;
 582         writel(tmp, MX6_DBI_ADDR + 0x7c);
 583
 584         /* LTSSM enable, starting link. */
 585         setbits_le32(&iomuxc_regs->gpr[12], IOMUXC_GPR12_APPS_LTSSM_ENABLE);
 586
 587         while (!imx6_pcie_link_up()) {
 588                 udelay(10);
 589                 count++;
 590                 if (count >= 2000) {
 591                         debug("phy link never came up\n");
 592                         debug("DEBUG_R0: 0x%08x, DEBUG_R1: 0x%08x\n",
 593                               readl(MX6_DBI_ADDR + PCIE_PHY_DEBUG_R0),
 594                               readl(MX6_DBI_ADDR + PCIE_PHY_DEBUG_R1));
 595                         return -EINVAL;
 596                 }
 597         }
 598
 599         return 0;
 600 }
 601
 602 void imx_pcie_init(void)
 603 {
 604         /* Static instance of the controller. */
 605         static struct pci_controller    pcc;
 606         struct pci_controller           *hose = &pcc;
 607         int ret;
 608
 609         memset(&pcc, 0, sizeof(pcc));
 610
 611         /* PCI I/O space */
 612         pci_set_region(&hose->regions[0],
 613                        MX6_IO_ADDR, MX6_IO_ADDR,
 614                        MX6_IO_SIZE, PCI_REGION_IO);
 615
 616         /* PCI memory space */
 617         pci_set_region(&hose->regions[1],
 618                        MX6_MEM_ADDR, MX6_MEM_ADDR,
 619                        MX6_MEM_SIZE, PCI_REGION_MEM);
 620
 621         /* System memory space */
 622         pci_set_region(&hose->regions[2],
 623                        MMDC0_ARB_BASE_ADDR, MMDC0_ARB_BASE_ADDR,
 624                        0xefffffff, PCI_REGION_MEM | PCI_REGION_SYS_MEMORY);
 625
 626         hose->region_count = 3;
 627
 628         pci_set_ops(hose,
 629                     pci_hose_read_config_byte_via_dword,
 630                     pci_hose_read_config_word_via_dword,
 631                     imx_pcie_read_config,
 632                     pci_hose_write_config_byte_via_dword,
 633                     pci_hose_write_config_word_via_dword,
 634                     imx_pcie_write_config);
 635
 636         /* Start the controller. */
 637         ret = imx_pcie_link_up();
 638
 639         if (!ret) {
 640                 pci_register_hose(hose);
 641                 hose->last_busno = pci_hose_scan(hose);
 642         }
 643 }
 644
 645 /* Probe function. */
 646 void pci_init_board(void)
 647 {
 648         imx_pcie_init();
 649 }