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