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