Root/target/linux/lantiq/patches-3.7/0122-MIPS-lantiq-adds-pcie-driver.patch

1From b0b68cd5b5da72950863af882c368f28f65690e8 Mon Sep 17 00:00:00 2001
2From: John Crispin <blogic@openwrt.org>
3Date: Thu, 6 Dec 2012 11:43:53 +0100
4Subject: [PATCH 122/123] MIPS: lantiq: adds pcie driver
5
6---
7 arch/mips/lantiq/Kconfig | 10 +
8 arch/mips/lantiq/xway/sysctrl.c | 2 +
9 arch/mips/pci/Makefile | 2 +
10 arch/mips/pci/fixup-lantiq-pcie.c | 82 ++
11 arch/mips/pci/fixup-lantiq.c | 3 +
12 arch/mips/pci/ifxmips_pci_common.h | 57 ++
13 arch/mips/pci/ifxmips_pcie.c | 1607 ++++++++++++++++++++++++++++++++++++
14 arch/mips/pci/ifxmips_pcie.h | 135 +++
15 arch/mips/pci/ifxmips_pcie_ar10.h | 290 +++++++
16 arch/mips/pci/ifxmips_pcie_msi.c | 392 +++++++++
17 arch/mips/pci/ifxmips_pcie_phy.c | 478 +++++++++++
18 arch/mips/pci/ifxmips_pcie_pm.c | 176 ++++
19 arch/mips/pci/ifxmips_pcie_pm.h | 36 +
20 arch/mips/pci/ifxmips_pcie_reg.h | 1001 ++++++++++++++++++++++
21 arch/mips/pci/ifxmips_pcie_vr9.h | 271 ++++++
22 arch/mips/pci/pci.c | 25 +
23 drivers/pci/pcie/aer/Kconfig | 2 +-
24 include/linux/pci.h | 2 +
25 include/linux/pci_ids.h | 6 +
26 19 files changed, 4576 insertions(+), 1 deletion(-)
27 create mode 100644 arch/mips/pci/fixup-lantiq-pcie.c
28 create mode 100755 arch/mips/pci/ifxmips_pci_common.h
29 create mode 100644 arch/mips/pci/ifxmips_pcie.c
30 create mode 100644 arch/mips/pci/ifxmips_pcie.h
31 create mode 100644 arch/mips/pci/ifxmips_pcie_ar10.h
32 create mode 100644 arch/mips/pci/ifxmips_pcie_msi.c
33 create mode 100644 arch/mips/pci/ifxmips_pcie_phy.c
34 create mode 100644 arch/mips/pci/ifxmips_pcie_pm.c
35 create mode 100644 arch/mips/pci/ifxmips_pcie_pm.h
36 create mode 100644 arch/mips/pci/ifxmips_pcie_reg.h
37 create mode 100644 arch/mips/pci/ifxmips_pcie_vr9.h
38
39diff --git a/arch/mips/lantiq/Kconfig b/arch/mips/lantiq/Kconfig
40index edeb58c..116765a 100644
41--- a/arch/mips/lantiq/Kconfig
42+++ b/arch/mips/lantiq/Kconfig
43@@ -17,6 +17,7 @@ config SOC_XWAY
44     bool "XWAY"
45     select SOC_TYPE_XWAY
46     select HW_HAS_PCI
47+ select ARCH_SUPPORTS_MSI
48 
49 config SOC_FALCON
50     bool "FALCON"
51@@ -40,6 +41,15 @@ config PCI_LANTIQ
52     bool "PCI Support"
53     depends on SOC_XWAY && PCI
54 
55+config PCIE_LANTIQ
56+ bool "PCIE Support"
57+ depends on SOC_XWAY && PCI
58+
59+config PCIE_LANTIQ_MSI
60+ bool
61+ depends on PCIE_LANTIQ && PCI_MSI
62+ default y
63+
64 config XRX200_PHY_FW
65     bool "XRX200 PHY firmware loader"
66     depends on SOC_XWAY
67diff --git a/arch/mips/lantiq/xway/sysctrl.c b/arch/mips/lantiq/xway/sysctrl.c
68index 75e1b7d..b077d49 100644
69--- a/arch/mips/lantiq/xway/sysctrl.c
70+++ b/arch/mips/lantiq/xway/sysctrl.c
71@@ -377,6 +377,8 @@ void __init ltq_soc_init(void)
72                 PMU_PPE_EMA | PMU_PPE_TC | PMU_PPE_SLL01 |
73                 PMU_PPE_QSB | PMU_PPE_TOP);
74         clkdev_add_pmu("1f203000.rcu", "gphy", 0, PMU_GPHY);
75+ pmu_w32(~0, PMU_PWDSR1);
76+ pmu_w32(pmu_r32(PMU_PWDSR) & ~PMU_PCIE_CLK, PMU_PWDSR);
77     } else if (of_machine_is_compatible("lantiq,ar9")) {
78         clkdev_add_static(ltq_ar9_cpu_hz(), ltq_ar9_fpi_hz(),
79                 ltq_ar9_fpi_hz(), CLOCK_250M);
80diff --git a/arch/mips/pci/Makefile b/arch/mips/pci/Makefile
81index e13a71c..46d7096 100644
82--- a/arch/mips/pci/Makefile
83+++ b/arch/mips/pci/Makefile
84@@ -44,6 +44,8 @@ obj-$(CONFIG_SIBYTE_BCM1x80) += pci-bcm1480.o pci-bcm1480ht.o
85 obj-$(CONFIG_SNI_RM) += fixup-sni.o ops-sni.o
86 obj-$(CONFIG_LANTIQ) += fixup-lantiq.o
87 obj-$(CONFIG_PCI_LANTIQ) += pci-lantiq.o ops-lantiq.o
88+obj-$(CONFIG_PCIE_LANTIQ) += ifxmips_pcie_phy.o ifxmips_pcie.o fixup-lantiq-pcie.o
89+obj-$(CONFIG_PCIE_LANTIQ_MSI) += pcie-lantiq-msi.o
90 obj-$(CONFIG_TANBAC_TB0219) += fixup-tb0219.o
91 obj-$(CONFIG_TANBAC_TB0226) += fixup-tb0226.o
92 obj-$(CONFIG_TANBAC_TB0287) += fixup-tb0287.o
93diff --git a/arch/mips/pci/fixup-lantiq-pcie.c b/arch/mips/pci/fixup-lantiq-pcie.c
94new file mode 100644
95index 0000000..50a1c3b
96--- /dev/null
97+++ b/arch/mips/pci/fixup-lantiq-pcie.c
98@@ -0,0 +1,82 @@
99+/******************************************************************************
100+**
101+** FILE NAME : ifxmips_fixup_pcie.c
102+** PROJECT : IFX UEIP for VRX200
103+** MODULES : PCIe
104+**
105+** DATE : 02 Mar 2009
106+** AUTHOR : Lei Chuanhua
107+** DESCRIPTION : PCIe Root Complex Driver
108+** COPYRIGHT : Copyright (c) 2009
109+** Infineon Technologies AG
110+** Am Campeon 1-12, 85579 Neubiberg, Germany
111+**
112+** This program is free software; you can redistribute it and/or modify
113+** it under the terms of the GNU General Public License as published by
114+** the Free Software Foundation; either version 2 of the License, or
115+** (at your option) any later version.
116+** HISTORY
117+** $Version $Date $Author $Comment
118+** 0.0.1 17 Mar,2009 Lei Chuanhua Initial version
119+*******************************************************************************/
120+/*!
121+ \file ifxmips_fixup_pcie.c
122+ \ingroup IFX_PCIE
123+ \brief PCIe Fixup functions source file
124+*/
125+#include <linux/pci.h>
126+#include <linux/pci_regs.h>
127+#include <linux/pci_ids.h>
128+
129+#include <lantiq_soc.h>
130+
131+#include "pcie-lantiq.h"
132+
133+#define PCI_VENDOR_ID_INFINEON 0x15D1
134+#define PCI_DEVICE_ID_INFINEON_DANUBE 0x000F
135+#define PCI_DEVICE_ID_INFINEON_PCIE 0x0011
136+#define PCI_VENDOR_ID_LANTIQ 0x1BEF
137+#define PCI_DEVICE_ID_LANTIQ_PCIE 0x0011
138+
139+
140+
141+static void __devinit
142+ifx_pcie_fixup_resource(struct pci_dev *dev)
143+{
144+ u32 reg;
145+
146+ IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s dev %s: enter\n", __func__, pci_name(dev));
147+
148+ printk("%s: fixup host controller %s (%04x:%04x)\n",
149+ __func__, pci_name(dev), dev->vendor, dev->device);
150+
151+ /* Setup COMMAND register */
152+ reg = PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER /* |
153+ PCI_COMMAND_INTX_DISABLE */| PCI_COMMAND_SERR;
154+ pci_write_config_word(dev, PCI_COMMAND, reg);
155+ IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s dev %s: exit\n", __func__, pci_name(dev));
156+}
157+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INFINEON, PCI_DEVICE_ID_INFINEON_PCIE, ifx_pcie_fixup_resource);
158+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_LANTIQ, PCI_VENDOR_ID_LANTIQ, ifx_pcie_fixup_resource);
159+
160+static void __devinit
161+ifx_pcie_rc_class_early_fixup(struct pci_dev *dev)
162+{
163+ IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s dev %s: enter\n", __func__, pci_name(dev));
164+
165+ if (dev->devfn == PCI_DEVFN(0, 0) &&
166+ (dev->class >> 8) == PCI_CLASS_BRIDGE_HOST) {
167+
168+ dev->class = (PCI_CLASS_BRIDGE_PCI << 8) | (dev->class & 0xff);
169+
170+ printk(KERN_INFO "%s: fixed pcie host bridge to pci-pci bridge\n", __func__);
171+ }
172+ IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s dev %s: exit\n", __func__, pci_name(dev));
173+ mdelay(10);
174+}
175+
176+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INFINEON, PCI_DEVICE_ID_INFINEON_PCIE,
177+ ifx_pcie_rc_class_early_fixup);
178+
179+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_LANTIQ, PCI_DEVICE_ID_LANTIQ_PCIE,
180+ ifx_pcie_rc_class_early_fixup);
181diff --git a/arch/mips/pci/fixup-lantiq.c b/arch/mips/pci/fixup-lantiq.c
182index 6c829df..cf5c4e0 100644
183--- a/arch/mips/pci/fixup-lantiq.c
184+++ b/arch/mips/pci/fixup-lantiq.c
185@@ -11,6 +11,7 @@
186 
187 int (*ltq_pci_plat_arch_init)(struct pci_dev *dev) = NULL;
188 int (*ltq_pci_plat_dev_init)(struct pci_dev *dev) = NULL;
189+int (*ltq_pci_map_irq)(const struct pci_dev *dev, u8 slot, u8 pin);
190 
191 int pcibios_plat_dev_init(struct pci_dev *dev)
192 {
193@@ -28,6 +29,8 @@ int __init pcibios_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
194     struct of_irq dev_irq;
195     int irq;
196 
197+ if (ltq_pci_map_irq)
198+ return ltq_pci_map_irq(dev, slot, pin);
199     if (of_irq_map_pci(dev, &dev_irq)) {
200         dev_err(&dev->dev, "trying to map irq for unknown slot:%d pin:%d\n",
201             slot, pin);
202diff --git a/arch/mips/pci/ifxmips_pci_common.h b/arch/mips/pci/ifxmips_pci_common.h
203new file mode 100755
204index 0000000..5f6ab83
205--- /dev/null
206+++ b/arch/mips/pci/ifxmips_pci_common.h
207@@ -0,0 +1,57 @@
208+/******************************************************************************
209+**
210+** FILE NAME : ifxmips_pci_common.h
211+** PROJECT : IFX UEIP
212+** MODULES : PCI subsystem
213+**
214+** DATE : 30 June 2009
215+** AUTHOR : Lei Chuanhua
216+** DESCRIPTION : PCIe Root Complex Driver
217+** COPYRIGHT : Copyright (c) 2009
218+** Infineon Technologies AG
219+** Am Campeon 1-12, 85579 Neubiberg, Germany
220+**
221+** This program is free software; you can redistribute it and/or modify
222+** it under the terms of the GNU General Public License as published by
223+** the Free Software Foundation; either version 2 of the License, or
224+** (at your option) any later version.
225+** HISTORY
226+** $Version $Date $Author $Comment
227+** 0.0.1 30 June,2009 Lei Chuanhua Initial version
228+*******************************************************************************/
229+
230+#ifndef IFXMIPS_PCI_COMMON_H
231+#define IFXMIPS_PCI_COMMON_H
232+#include <linux/version.h>
233+/*!
234+ \defgroup IFX_PCI_COM IFX PCI/PCIe common parts for OS integration
235+ \brief PCI/PCIe common parts
236+*/
237+
238+/*!
239+ \defgroup IFX_PCI_COM_OS OS APIs
240+ \ingroup IFX_PCI_COM
241+ \brief PCI/PCIe bus driver OS interface functions
242+*/
243+/*!
244+ \file ifxmips_pci_common.h
245+ \ingroup IFX_PCI_COM
246+ \brief PCI/PCIe bus driver common OS header file
247+*/
248+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
249+#define IFX_PCI_CONST
250+#else
251+#define IFX_PCI_CONST const
252+#endif
253+#ifdef CONFIG_IFX_PCI
254+extern int ifx_pci_bios_map_irq(IFX_PCI_CONST struct pci_dev *dev, u8 slot, u8 pin);
255+extern int ifx_pci_bios_plat_dev_init(struct pci_dev *dev);
256+#endif /* COFNIG_IFX_PCI */
257+
258+#ifdef CONFIG_IFX_PCIE
259+extern int ifx_pcie_bios_map_irq(IFX_PCI_CONST struct pci_dev *dev, u8 slot, u8 pin);
260+extern int ifx_pcie_bios_plat_dev_init(struct pci_dev *dev);
261+#endif
262+
263+#endif /* IFXMIPS_PCI_COMMON_H */
264+
265diff --git a/arch/mips/pci/ifxmips_pcie.c b/arch/mips/pci/ifxmips_pcie.c
266new file mode 100644
267index 0000000..de6e2fa
268--- /dev/null
269+++ b/arch/mips/pci/ifxmips_pcie.c
270@@ -0,0 +1,1607 @@
271+/******************************************************************************
272+**
273+** FILE NAME : ifxmips_pcie.c
274+** PROJECT : IFX UEIP for VRX200
275+** MODULES : PCI MSI sub module
276+**
277+** DATE : 02 Mar 2009
278+** AUTHOR : Lei Chuanhua
279+** DESCRIPTION : PCIe Root Complex Driver
280+** COPYRIGHT : Copyright (c) 2009
281+** Infineon Technologies AG
282+** Am Campeon 1-12, 85579 Neubiberg, Germany
283+**
284+** This program is free software; you can redistribute it and/or modify
285+** it under the terms of the GNU General Public License as published by
286+** the Free Software Foundation; either version 2 of the License, or
287+** (at your option) any later version.
288+** HISTORY
289+** $Version $Date $Author $Comment
290+** 0.0.1 02 Mar,2009 Lei Chuanhua Initial version
291+*******************************************************************************/
292+ /*!
293+ \file ifxmips_pcie.c
294+ \ingroup IFX_PCIE
295+ \brief PCI express bus driver source file
296+*/
297+#include <linux/types.h>
298+#include <linux/pci.h>
299+#include <linux/kernel.h>
300+#include <linux/init.h>
301+#include <linux/delay.h>
302+#include <linux/mm.h>
303+#include <asm/paccess.h>
304+#include <linux/pci.h>
305+#include <linux/pci_regs.h>
306+#include <linux/module.h>
307+
308+#include "ifxmips_pcie.h"
309+#include "ifxmips_pcie_reg.h"
310+
311+#define IFX_PCIE_VER_MAJOR 1
312+#define IFX_PCIE_VER_MID 5
313+#define IFX_PCIE_VER_MINOR 3
314+
315+/* Enable 32bit io due to its mem mapped io nature */
316+#define IFX_PCIE_ERROR_INT
317+#define CONFIG_IFX_PCIE_1ST_CORE
318+#define IFX_PCIE_IO_32BIT
319+
320+#define IFX_PCIE_IR (INT_NUM_IM4_IRL0 + 25)
321+#define IFX_PCIE_INTA (INT_NUM_IM4_IRL0 + 8)
322+#define IFX_PCIE_INTB (INT_NUM_IM4_IRL0 + 9)
323+#define IFX_PCIE_INTC (INT_NUM_IM4_IRL0 + 10)
324+#define IFX_PCIE_INTD (INT_NUM_IM4_IRL0 + 11)
325+#define MS(_v, _f) (((_v) & (_f)) >> _f##_S)
326+#define SM(_v, _f) (((_v) << _f##_S) & (_f))
327+#define IFX_REG_SET_BIT(_f, _r) \
328+ IFX_REG_W32((IFX_REG_R32((_r)) &~ (_f)) | (_f), (_r))
329+
330+static DEFINE_SPINLOCK(ifx_pcie_lock);
331+
332+u32 g_pcie_debug_flag = PCIE_MSG_ANY & (~PCIE_MSG_CFG);
333+
334+static ifx_pcie_irq_t pcie_irqs[IFX_PCIE_CORE_NR] = {
335+ {
336+ .ir_irq = {
337+ .irq = IFX_PCIE_IR,
338+ .name = "ifx_pcie_rc0",
339+ },
340+
341+ .legacy_irq = {
342+ {
343+ .irq_bit = PCIE_IRN_INTA,
344+ .irq = IFX_PCIE_INTA,
345+ },
346+ {
347+ .irq_bit = PCIE_IRN_INTB,
348+ .irq = IFX_PCIE_INTB,
349+ },
350+ {
351+ .irq_bit = PCIE_IRN_INTC,
352+ .irq = IFX_PCIE_INTC,
353+ },
354+ {
355+ .irq_bit = PCIE_IRN_INTD,
356+ .irq = IFX_PCIE_INTD,
357+ },
358+ },
359+ },
360+
361+#ifdef CONFIG_IFX_PCIE_2ND_CORE
362+ {
363+ .ir_irq = {
364+ .irq = IFX_PCIE1_IR,
365+ .name = "ifx_pcie_rc1",
366+ },
367+
368+ .legacy_irq = {
369+ {
370+ .irq_bit = PCIE_IRN_INTA,
371+ .irq = IFX_PCIE1_INTA,
372+ },
373+ {
374+ .irq_bit = PCIE_IRN_INTB,
375+ .irq = IFX_PCIE1_INTB,
376+ },
377+ {
378+ .irq_bit = PCIE_IRN_INTC,
379+ .irq = IFX_PCIE1_INTC,
380+ },
381+ {
382+ .irq_bit = PCIE_IRN_INTD,
383+ .irq = IFX_PCIE1_INTD,
384+ },
385+ },
386+
387+ },
388+#endif /* CONFIG_IFX_PCIE_2ND_CORE */
389+};
390+
391+void
392+ifx_pcie_debug(const char *fmt, ...)
393+{
394+ static char buf[256] = {0}; /* XXX */
395+ va_list ap;
396+
397+ va_start(ap, fmt);
398+ vsnprintf(buf, sizeof(buf), fmt, ap);
399+ va_end(ap);
400+
401+ printk("%s", buf);
402+}
403+
404+#ifdef IFX_PCI_PHY_DBG
405+/* Generate hot reset, XXX must catpure to verify */
406+static INLINE void
407+pcie_secondary_bus_reset(int pcie_port)
408+{
409+ int i;
410+ u32 reg;
411+#define IFX_PCIE_RESET_TIME 20
412+
413+ /* Assert Secondary Bus Reset */
414+ reg = IFX_REG_R32(PCIE_INTRBCTRL(pcie_port));
415+ reg |= PCIE_INTRBCTRL_RST_SECONDARY_BUS;
416+ IFX_REG_W32(reg, PCIE_INTRBCTRL(pcie_port));
417+
418+ /* De-assert Secondary Bus Reset */
419+ reg &= ~PCIE_INTRBCTRL_RST_SECONDARY_BUS;
420+ IFX_REG_W32(reg, PCIE_INTRBCTRL(pcie_port));
421+
422+ /* XXX, wait at least 100 ms, then restore again */
423+ for (i = 0; i < IFX_PCIE_RESET_TIME; i++) {
424+ mdelay(10);
425+ }
426+#undef IFX_PCIE_RESET_TIME
427+}
428+
429+/* Error or L0s to L0 */
430+static INLINE int
431+pcie_retrain_link(int pcie_port)
432+{
433+ int i;
434+ u32 reg;
435+#define IFX_PCIE_RETRAIN_TIME 1000
436+
437+ reg = IFX_REG_R32(PCIE_LCTLSTS(pcie_port));
438+ reg |= PCIE_LCTLSTS_RETRIAN_LINK;
439+ IFX_REG_W32(reg, PCIE_LCTLSTS(pcie_port));
440+
441+ /* Wait for the link to come up */
442+ for (i = 0; i < IFX_PCIE_RETRAIN_TIME; i++) {
443+ if (!(IFX_REG_R32(PCIE_LCTLSTS(pcie_port)) & PCIE_LCTLSTS_RETRAIN_PENDING)) {
444+ break;
445+ }
446+ udelay(100);
447+ }
448+ if (i >= IFX_PCIE_RETRAIN_TIME) {
449+ IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s retrain timeout\n", __func__);
450+ return -1;
451+ }
452+ return 0;
453+#undef IFX_PCIE_RETRAIN_TIME
454+}
455+
456+static INLINE void
457+pcie_disable_scrambling(int pcie_port)
458+{
459+ u32 reg;
460+
461+ reg = IFX_REG_R32(PCIE_PLCR(pcie_port));
462+ reg |= PCIE_PLCR_SCRAMBLE_DISABLE;
463+ IFX_REG_W32(reg, PCIE_PLCR(pcie_port));
464+}
465+#endif /* IFX_PCI_PHY_DBG */
466+
467+static INLINE int
468+pcie_ltssm_enable(int pcie_port)
469+{
470+ int i;
471+#define IFX_PCIE_LTSSM_ENABLE_TIMEOUT 10
472+
473+ IFX_REG_W32(PCIE_RC_CCR_LTSSM_ENABLE, PCIE_RC_CCR(pcie_port)); /* Enable LTSSM */
474+
475+ /* Wait for the link to come up */
476+ for (i = 0; i < IFX_PCIE_LTSSM_ENABLE_TIMEOUT; i++) {
477+ if (!(IFX_REG_R32(PCIE_LCTLSTS(pcie_port)) & PCIE_LCTLSTS_RETRAIN_PENDING)) {
478+ break;
479+ }
480+ udelay(10);
481+ }
482+ if (i >= IFX_PCIE_LTSSM_ENABLE_TIMEOUT) {
483+ IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s link timeout!!!!!\n", __func__);
484+ return -1;
485+ }
486+ return 0;
487+#undef IFX_PCIE_LTSSM_ENABLE_TIMEOUT
488+}
489+
490+static INLINE void
491+pcie_ltssm_disable(int pcie_port)
492+{
493+ IFX_REG_W32(0, PCIE_RC_CCR(pcie_port)); /* Disable LTSSM */
494+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_RC_CCR 0x%08x\n",
495+ __func__, IFX_REG_R32(PCIE_RC_CCR(pcie_port)));
496+}
497+
498+static INLINE void
499+pcie_ahb_bus_error_suppress(int pcie_port)
500+{
501+ IFX_REG_W32(PCIE_AHB_CTRL_BUS_ERROR_SUPPRESS, PCIE_AHB_CTRL(pcie_port));
502+}
503+
504+static INLINE void
505+pcie_status_register_clear(int pcie_port)
506+{
507+ /* Clear the status register, XXX, seperate function */
508+ IFX_REG_W32(0, PCIE_RC_DR(pcie_port));
509+ IFX_REG_W32(0, PCIE_PCICMDSTS(pcie_port));
510+ IFX_REG_W32(0, PCIE_DCTLSTS(pcie_port));
511+ IFX_REG_W32(0, PCIE_LCTLSTS(pcie_port));
512+ IFX_REG_W32(0, PCIE_SLCTLSTS(pcie_port));
513+ IFX_REG_W32(0, PCIE_RSTS(pcie_port));
514+ IFX_REG_W32(0, PCIE_UES_R(pcie_port));
515+ IFX_REG_W32(0, PCIE_UEMR(pcie_port));
516+ IFX_REG_W32(0, PCIE_UESR(pcie_port));
517+ IFX_REG_W32(0, PCIE_CESR(pcie_port));
518+ IFX_REG_W32(0, PCIE_CEMR(pcie_port));
519+ IFX_REG_W32(0, PCIE_RESR(pcie_port));
520+ IFX_REG_W32(0, PCIE_PVCCRSR(pcie_port));
521+ IFX_REG_W32(0, PCIE_VC0_RSR0(pcie_port));
522+ IFX_REG_W32(0, PCIE_TPFCS(pcie_port));
523+ IFX_REG_W32(0, PCIE_TNPFCS(pcie_port));
524+ IFX_REG_W32(0, PCIE_TCFCS(pcie_port));
525+ IFX_REG_W32(0, PCIE_QSR(pcie_port));
526+ IFX_REG_W32(0, PCIE_IOBLSECS(pcie_port));
527+}
528+
529+static inline int
530+ifx_pcie_link_up(int pcie_port)
531+{
532+ return (IFX_REG_R32(PCIE_PHY_SR(pcie_port)) & PCIE_PHY_SR_PHY_LINK_UP) ? 1 : 0;
533+}
534+
535+#ifdef IFX_PCIE_DBG
536+static void
537+pcie_status_registers_dump(int pcie_port)
538+{
539+ printk(KERN_INFO "PCIe_PCICMDSTS: 0x%08x\n", IFX_REG_R32(PCIE_PCICMDSTS(pcie_port)));
540+ printk(KERN_INFO "PCIe_RC_DR: 0x%08x\n", IFX_REG_R32(PCIE_RC_DR(pcie_port)));
541+ printk(KERN_INFO "PCIe_DCTLSTS: 0x%08x\n", IFX_REG_R32(PCIE_DCTLSTS(pcie_port)));
542+ printk(KERN_INFO "PCIe_LCTLSTS: 0x%08x\n", IFX_REG_R32(PCIE_LCTLSTS(pcie_port)));
543+ printk(KERN_INFO "PCIe_SLCTLSTS: 0x%08x\n", IFX_REG_R32(PCIE_SLCTLSTS(pcie_port)));
544+ printk(KERN_INFO "PCIe_RSTS: 0x%08x\n", IFX_REG_R32(PCIE_RSTS(pcie_port)));
545+ printk(KERN_INFO "PCIe_UES_R: 0x%08x\n", IFX_REG_R32(PCIE_UES_R(pcie_port)));
546+ printk(KERN_INFO "PCIe_UEMR: 0x%08x\n", IFX_REG_R32(PCIE_UEMR(pcie_port)));
547+ printk(KERN_INFO "PCIe_UESR: 0x%08x\n", IFX_REG_R32(PCIE_UESR(pcie_port)));
548+ printk(KERN_INFO "PCIe_CESR: 0x%08x\n", IFX_REG_R32(PCIE_CESR(pcie_port)));
549+ printk(KERN_INFO "PCIe_CEMR: 0x%08x\n", IFX_REG_R32(PCIE_CEMR(pcie_port)));
550+ printk(KERN_INFO "PCIe_RESR: 0x%08x\n", IFX_REG_R32(PCIE_RESR(pcie_port)));
551+ printk(KERN_INFO "PCIe_ESIR: 0x%08x\n", IFX_REG_R32(PCIE_ESIR(pcie_port)));
552+ printk(KERN_INFO "PCIe_PVCCRSR: 0x%08x\n", IFX_REG_R32(PCIE_PVCCRSR(pcie_port)));
553+ printk(KERN_INFO "PCIe_VC0_RSR0: 0x%08x\n", IFX_REG_R32(PCIE_VC0_RSR0(pcie_port)));
554+ printk(KERN_INFO "PCIe_TPFCS: 0x%08x\n", IFX_REG_R32(PCIE_TPFCS(pcie_port)));
555+ printk(KERN_INFO "PCIe_TNPFCS: 0x%08x\n", IFX_REG_R32(PCIE_TNPFCS(pcie_port)));
556+ printk(KERN_INFO "PCIe_TCFCS: 0x%08x\n", IFX_REG_R32(PCIE_TCFCS(pcie_port)));
557+ printk(KERN_INFO "PCIe_QSR: 0x%08x\n", IFX_REG_R32(PCIE_QSR(pcie_port)));
558+ printk(KERN_INFO "PCIe_VCTAR1: 0x%08x\n", IFX_REG_R32(PCIE_VCTAR1(pcie_port)));
559+ printk(KERN_INFO "PCIe_VCTAR2: 0x%08x\n", IFX_REG_R32(PCIE_VCTAR2(pcie_port)));
560+ printk(KERN_INFO "PCIe_IOBLSECS: 0x%08x\n", IFX_REG_R32(PCIE_IOBLSECS(pcie_port)));
561+ printk(KERN_INFO "PCIe_ALTRT: 0x%08x\n", IFX_REG_R32(PCIE_ALTRT(pcie_port)));
562+ printk(KERN_INFO "PCIe_SNR: 0x%08x\n", IFX_REG_R32(PCIE_SNR(pcie_port)));
563+ printk(KERN_INFO "PCIe_DBR0: 0x%08x\n", IFX_REG_R32(PCIE_DBR0(pcie_port)));
564+ printk(KERN_INFO "PCIe_DBR1: 0x%08x\n", IFX_REG_R32(PCIE_DBR1(pcie_port)));
565+}
566+
567+static void
568+pcie_post_dump(int pcie_port)
569+{
570+ printk(KERN_INFO "PCIe_PCICMDSTS: 0x%08x\n", IFX_REG_R32(PCIE_PCICMDSTS(pcie_port)));
571+ printk(KERN_INFO "PCIe_MBML: 0x%08x\n", IFX_REG_R32(PCIE_MBML(pcie_port)));
572+ printk(KERN_INFO "PCIe_PBML: 0x%08x\n", IFX_REG_R32(PCIE_PMBL(pcie_port)));
573+ printk(KERN_INFO "PCIe_IOBLSECS: 0x%08x\n", IFX_REG_R32(PCIE_IOBLSECS(pcie_port)));
574+ printk(KERN_INFO "PCIe_IO_BANDL: 0x%08x\n", IFX_REG_R32(PCIE_IO_BANDL(pcie_port)));
575+ printk(KERN_INFO "PCIe_INTRBCTRL: 0x%08x\n", IFX_REG_R32(PCIE_INTRBCTRL(pcie_port)));
576+ printk(KERN_INFO "Power State: D%1d\n", IFX_REG_R32(PCIE_PM_CSR(pcie_port)) & PCIE_PM_CSR_POWER_STATE);
577+ printk(KERN_INFO "Negotiated Link Width: %d\n", MS(IFX_REG_R32(PCIE_LCTLSTS(pcie_port)), PCIE_LCTLSTS_NEGOTIATED_LINK_WIDTH));
578+ printk(KERN_INFO "Number of VCs: %d\n", IFX_REG_R32(PCIE_PVC1(pcie_port)) & PCIE_PVC1_EXT_VC_CNT);
579+ printk(KERN_INFO "Low-priority VCs: %d\n", MS(IFX_REG_R32(PCIE_PVC1(pcie_port)), PCIE_PVC1_LOW_PRI_EXT_VC_CNT));
580+ printk(KERN_INFO "VC Arbitration: 0x%08x\n", IFX_REG_R32(PCIE_PVC2(pcie_port)) & PCIE_PVC2_VC_ARB_WRR);
581+ printk(KERN_INFO "Port Arbitration: 0x%08x\n", IFX_REG_R32(PCIE_VC0_RC(pcie_port)) & PCIE_VC0_RC_PORT_ARB);
582+
583+ if (ifx_pcie_link_up(pcie_port)) {
584+ printk(KERN_INFO "PCIe PHY Link is UP\n");
585+ }
586+ else {
587+ printk(KERN_INFO "PCIe PHY Link is DOWN!\n");
588+ }
589+ if ((IFX_REG_R32(PCIE_RC_DR(pcie_port)) & PCIE_RC_DR_DLL_UP)) {
590+ printk(KERN_INFO "PCIe DLL is UP\n");
591+ }
592+ else {
593+ printk(KERN_INFO "PCIe DLL is DOWN!\n");
594+ }
595+
596+ if ((IFX_REG_R32(PCIE_LCTLSTS(pcie_port)) & PCIE_LCTLSTS_DLL_ACTIVE)) {
597+ printk(KERN_INFO "PCIE_LCTLSTS in DL_Active state!\n");
598+ }
599+ else {
600+ printk(KERN_INFO "PCIE_LCTLSTS NOT in DL_Active state!\n");
601+ }
602+ }
603+#endif /* IFX_PCIE_DBG */
604+
605+/* XXX, this function is not needed in fact */
606+static INLINE void
607+pcie_mem_io_setup(int pcie_port)
608+{
609+ u32 reg;
610+ /*
611+ * BAR[0:1] readonly register
612+ * RC contains only minimal BARs for packets mapped to this device
613+ * Mem/IO filters defines a range of memory occupied by memory mapped IO devices that
614+ * reside on the downstream side fo the bridge.
615+ */
616+ reg = SM((PCIE_MEM_PHY_PORT_TO_END(pcie_port) >> 20), PCIE_MBML_MEM_LIMIT_ADDR)
617+ | SM((PCIE_MEM_PHY_PORT_TO_BASE(pcie_port) >> 20), PCIE_MBML_MEM_BASE_ADDR);
618+
619+ IFX_REG_W32(reg, PCIE_MBML(pcie_port));
620+
621+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_MBML: 0x%08x\n",
622+ __func__, IFX_REG_R32(PCIE_MBML(pcie_port)));
623+
624+#ifdef IFX_PCIE_PREFETCH_MEM_64BIT
625+ reg = SM((PCIE_MEM_PHY_PORT_TO_END(pcie_port) >> 20), PCIE_PMBL_END_ADDR)
626+ | SM((PCIE_MEM_PHY_PORT_TO_BASE(pcie_port) >> 20), PCIE_PMBL_UPPER_12BIT)
627+ | PCIE_PMBL_64BIT_ADDR;
628+ IFX_REG_W32(reg, PCIE_PMBL(pcie_port));
629+
630+ /* Must configure upper 32bit */
631+ IFX_REG_W32(0, PCIE_PMBU32(pcie_port));
632+ IFX_REG_W32(0, PCIE_PMLU32(pcie_port));
633+#else
634+ /* PCIe_PBML, same as MBML */
635+ IFX_REG_W32(IFX_REG_R32(PCIE_MBML(pcie_port)), PCIE_PMBL(pcie_port));
636+#endif
637+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_PMBL: 0x%08x\n",
638+ __func__, IFX_REG_R32(PCIE_PMBL(pcie_port)));
639+
640+ /* IO Address Range */
641+ reg = SM((PCIE_IO_PHY_PORT_TO_END(pcie_port) >> 12), PCIE_IOBLSECS_IO_LIMIT_ADDR)
642+ | SM((PCIE_IO_PHY_PORT_TO_BASE(pcie_port) >> 12), PCIE_IOBLSECS_IO_BASE_ADDR);
643+#ifdef IFX_PCIE_IO_32BIT
644+ reg |= PCIE_IOBLSECS_32BIT_IO_ADDR;
645+#endif /* IFX_PCIE_IO_32BIT */
646+ IFX_REG_W32(reg, PCIE_IOBLSECS(pcie_port));
647+
648+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_IOBLSECS: 0x%08x\n",
649+ __func__, IFX_REG_R32(PCIE_IOBLSECS(pcie_port)));
650+#ifdef IFX_PCIE_IO_32BIT
651+ reg = SM((PCIE_IO_PHY_PORT_TO_END(pcie_port) >> 16), PCIE_IO_BANDL_UPPER_16BIT_IO_LIMIT)
652+ | SM((PCIE_IO_PHY_PORT_TO_BASE(pcie_port) >> 16), PCIE_IO_BANDL_UPPER_16BIT_IO_BASE);
653+ IFX_REG_W32(reg, PCIE_IO_BANDL(pcie_port));
654+
655+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_IO_BANDL: 0x%08x\n",
656+ __func__, IFX_REG_R32(PCIE_IO_BANDL(pcie_port)));
657+#endif /* IFX_PCIE_IO_32BIT */
658+}
659+
660+static INLINE void
661+pcie_msi_setup(int pcie_port)
662+{
663+ u32 reg;
664+
665+ /* XXX, MSI stuff should only apply to EP */
666+ /* MSI Capability: Only enable 32-bit addresses */
667+ reg = IFX_REG_R32(PCIE_MCAPR(pcie_port));
668+ reg &= ~PCIE_MCAPR_ADDR64_CAP;
669+
670+ reg |= PCIE_MCAPR_MSI_ENABLE;
671+
672+ /* Disable multiple message */
673+ reg &= ~(PCIE_MCAPR_MULTI_MSG_CAP | PCIE_MCAPR_MULTI_MSG_ENABLE);
674+ IFX_REG_W32(reg, PCIE_MCAPR(pcie_port));
675+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_MCAPR: 0x%08x\n",
676+ __func__, IFX_REG_R32(PCIE_MCAPR(pcie_port)));
677+}
678+
679+static INLINE void
680+pcie_pm_setup(int pcie_port)
681+{
682+ u32 reg;
683+
684+ /* Enable PME, Soft reset enabled */
685+ reg = IFX_REG_R32(PCIE_PM_CSR(pcie_port));
686+ reg |= PCIE_PM_CSR_PME_ENABLE | PCIE_PM_CSR_SW_RST;
687+ IFX_REG_W32(reg, PCIE_PM_CSR(pcie_port));
688+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_PM_CSR: 0x%08x\n",
689+ __func__, IFX_REG_R32(PCIE_PM_CSR(pcie_port)));
690+}
691+
692+static INLINE void
693+pcie_bus_setup(int pcie_port)
694+{
695+ u32 reg;
696+
697+ reg = SM(0, PCIE_BNR_PRIMARY_BUS_NUM) | SM(1, PCIE_PNR_SECONDARY_BUS_NUM) | SM(0xFF, PCIE_PNR_SUB_BUS_NUM);
698+ IFX_REG_W32(reg, PCIE_BNR(pcie_port));
699+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_BNR: 0x%08x\n",
700+ __func__, IFX_REG_R32(PCIE_BNR(pcie_port)));
701+}
702+
703+static INLINE void
704+pcie_device_setup(int pcie_port)
705+{
706+ u32 reg;
707+
708+ /* Device capability register, set up Maximum payload size */
709+ reg = IFX_REG_R32(PCIE_DCAP(pcie_port));
710+ reg |= PCIE_DCAP_ROLE_BASE_ERR_REPORT;
711+ reg |= SM(PCIE_MAX_PAYLOAD_128, PCIE_DCAP_MAX_PAYLOAD_SIZE);
712+
713+ /* Only available for EP */
714+ reg &= ~(PCIE_DCAP_EP_L0S_LATENCY | PCIE_DCAP_EP_L1_LATENCY);
715+ IFX_REG_W32(reg, PCIE_DCAP(pcie_port));
716+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_DCAP: 0x%08x\n",
717+ __func__, IFX_REG_R32(PCIE_DCAP(pcie_port)));
718+
719+ /* Device control and status register */
720+ /* Set Maximum Read Request size for the device as a Requestor */
721+ reg = IFX_REG_R32(PCIE_DCTLSTS(pcie_port));
722+
723+ /*
724+ * Request size can be larger than the MPS used, but the completions returned
725+ * for the read will be bounded by the MPS size.
726+ * In our system, Max request size depends on AHB burst size. It is 64 bytes.
727+ * but we set it as 128 as minimum one.
728+ */
729+ reg |= SM(PCIE_MAX_PAYLOAD_128, PCIE_DCTLSTS_MAX_READ_SIZE)
730+ | SM(PCIE_MAX_PAYLOAD_128, PCIE_DCTLSTS_MAX_PAYLOAD_SIZE);
731+
732+ /* Enable relaxed ordering, no snoop, and all kinds of errors */
733+ reg |= PCIE_DCTLSTS_RELAXED_ORDERING_EN | PCIE_DCTLSTS_ERR_EN | PCIE_DCTLSTS_NO_SNOOP_EN;
734+
735+ IFX_REG_W32(reg, PCIE_DCTLSTS(pcie_port));
736+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_DCTLSTS: 0x%08x\n",
737+ __func__, IFX_REG_R32(PCIE_DCTLSTS(pcie_port)));
738+}
739+
740+static INLINE void
741+pcie_link_setup(int pcie_port)
742+{
743+ u32 reg;
744+
745+ /*
746+ * XXX, Link capability register, bit 18 for EP CLKREQ# dynamic clock management for L1, L2/3 CPM
747+ * L0s is reported during link training via TS1 order set by N_FTS
748+ */
749+ reg = IFX_REG_R32(PCIE_LCAP(pcie_port));
750+ reg &= ~PCIE_LCAP_L0S_EIXT_LATENCY;
751+ reg |= SM(3, PCIE_LCAP_L0S_EIXT_LATENCY);
752+ IFX_REG_W32(reg, PCIE_LCAP(pcie_port));
753+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_LCAP: 0x%08x\n",
754+ __func__, IFX_REG_R32(PCIE_LCAP(pcie_port)));
755+
756+ /* Link control and status register */
757+ reg = IFX_REG_R32(PCIE_LCTLSTS(pcie_port));
758+
759+ /* Link Enable, ASPM enabled */
760+ reg &= ~PCIE_LCTLSTS_LINK_DISABLE;
761+
762+#ifdef CONFIG_PCIEASPM
763+ /*
764+ * We use the same physical reference clock that the platform provides on the connector
765+ * It paved the way for ASPM to calculate the new exit Latency
766+ */
767+ reg |= PCIE_LCTLSTS_SLOT_CLK_CFG;
768+ reg |= PCIE_LCTLSTS_COM_CLK_CFG;
769+ /*
770+ * We should disable ASPM by default except that we have dedicated power management support
771+ * Enable ASPM will cause the system hangup/instability, performance degration
772+ */
773+ reg |= PCIE_LCTLSTS_ASPM_ENABLE;
774+#else
775+ reg &= ~PCIE_LCTLSTS_ASPM_ENABLE;
776+#endif /* CONFIG_PCIEASPM */
777+
778+ /*
779+ * The maximum size of any completion with data packet is bounded by the MPS setting
780+ * in device control register
781+ */
782+
783+ /* RCB may cause multiple split transactions, two options available, we use 64 byte RCB */
784+ reg &= ~ PCIE_LCTLSTS_RCB128;
785+
786+ IFX_REG_W32(reg, PCIE_LCTLSTS(pcie_port));
787+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_LCTLSTS: 0x%08x\n",
788+ __func__, IFX_REG_R32(PCIE_LCTLSTS(pcie_port)));
789+}
790+
791+static INLINE void
792+pcie_error_setup(int pcie_port)
793+{
794+ u32 reg;
795+
796+ /*
797+ * Forward ERR_COR, ERR_NONFATAL, ERR_FATAL to the backbone
798+ * Poisoned write TLPs and completions indicating poisoned TLPs will set the PCIe_PCICMDSTS.MDPE
799+ */
800+ reg = IFX_REG_R32(PCIE_INTRBCTRL(pcie_port));
801+ reg |= PCIE_INTRBCTRL_SERR_ENABLE | PCIE_INTRBCTRL_PARITY_ERR_RESP_ENABLE;
802+
803+ IFX_REG_W32(reg, PCIE_INTRBCTRL(pcie_port));
804+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_INTRBCTRL: 0x%08x\n",
805+ __func__, IFX_REG_R32(PCIE_INTRBCTRL(pcie_port)));
806+
807+ /* Uncorrectable Error Mask Register, Unmask <enable> all bits in PCIE_UESR */
808+ reg = IFX_REG_R32(PCIE_UEMR(pcie_port));
809+ reg &= ~PCIE_ALL_UNCORRECTABLE_ERR;
810+ IFX_REG_W32(reg, PCIE_UEMR(pcie_port));
811+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_UEMR: 0x%08x\n",
812+ __func__, IFX_REG_R32(PCIE_UEMR(pcie_port)));
813+
814+ /* Uncorrectable Error Severity Register, ALL errors are FATAL */
815+ IFX_REG_W32(PCIE_ALL_UNCORRECTABLE_ERR, PCIE_UESR(pcie_port));
816+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_UESR: 0x%08x\n",
817+ __func__, IFX_REG_R32(PCIE_UESR(pcie_port)));
818+
819+ /* Correctable Error Mask Register, unmask <enable> all bits */
820+ reg = IFX_REG_R32(PCIE_CEMR(pcie_port));
821+ reg &= ~PCIE_CORRECTABLE_ERR;
822+ IFX_REG_W32(reg, PCIE_CEMR(pcie_port));
823+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_CEMR: 0x%08x\n",
824+ __func__, IFX_REG_R32(PCIE_CEMR(pcie_port)));
825+
826+ /* Advanced Error Capabilities and Control Registr */
827+ reg = IFX_REG_R32(PCIE_AECCR(pcie_port));
828+ reg |= PCIE_AECCR_ECRC_CHECK_EN | PCIE_AECCR_ECRC_GEN_EN;
829+ IFX_REG_W32(reg, PCIE_AECCR(pcie_port));
830+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_AECCR: 0x%08x\n",
831+ __func__, IFX_REG_R32(PCIE_AECCR(pcie_port)));
832+
833+ /* Root Error Command Register, Report all types of errors */
834+ reg = IFX_REG_R32(PCIE_RECR(pcie_port));
835+ reg |= PCIE_RECR_ERR_REPORT_EN;
836+ IFX_REG_W32(reg, PCIE_RECR(pcie_port));
837+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_RECR: 0x%08x\n",
838+ __func__, IFX_REG_R32(PCIE_RECR(pcie_port)));
839+
840+ /* Clear the Root status register */
841+ reg = IFX_REG_R32(PCIE_RESR(pcie_port));
842+ IFX_REG_W32(reg, PCIE_RESR(pcie_port));
843+}
844+
845+static INLINE void
846+pcie_root_setup(int pcie_port)
847+{
848+ u32 reg;
849+
850+ /* Root control and capabilities register */
851+ reg = IFX_REG_R32(PCIE_RCTLCAP(pcie_port));
852+ reg |= PCIE_RCTLCAP_SERR_ENABLE | PCIE_RCTLCAP_PME_INT_EN;
853+ IFX_REG_W32(reg, PCIE_RCTLCAP(pcie_port));
854+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_RCTLCAP: 0x%08x\n",
855+ __func__, IFX_REG_R32(PCIE_RCTLCAP(pcie_port)));
856+}
857+
858+static INLINE void
859+pcie_vc_setup(int pcie_port)
860+{
861+ u32 reg;
862+
863+ /* Port VC Capability Register 2 */
864+ reg = IFX_REG_R32(PCIE_PVC2(pcie_port));
865+ reg &= ~PCIE_PVC2_VC_ARB_WRR;
866+ reg |= PCIE_PVC2_VC_ARB_16P_FIXED_WRR;
867+ IFX_REG_W32(reg, PCIE_PVC2(pcie_port));
868+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_PVC2: 0x%08x\n",
869+ __func__, IFX_REG_R32(PCIE_PVC2(pcie_port)));
870+
871+ /* VC0 Resource Capability Register */
872+ reg = IFX_REG_R32(PCIE_VC0_RC(pcie_port));
873+ reg &= ~PCIE_VC0_RC_REJECT_SNOOP;
874+ IFX_REG_W32(reg, PCIE_VC0_RC(pcie_port));
875+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_VC0_RC: 0x%08x\n",
876+ __func__, IFX_REG_R32(PCIE_VC0_RC(pcie_port)));
877+}
878+
879+static INLINE void
880+pcie_port_logic_setup(int pcie_port)
881+{
882+ u32 reg;
883+
884+ /* FTS number, default 12, increase to 63, may increase time from/to L0s to L0 */
885+ reg = IFX_REG_R32(PCIE_AFR(pcie_port));
886+ reg &= ~(PCIE_AFR_FTS_NUM | PCIE_AFR_COM_FTS_NUM);
887+ reg |= SM(PCIE_AFR_FTS_NUM_DEFAULT, PCIE_AFR_FTS_NUM)
888+ | SM(PCIE_AFR_FTS_NUM_DEFAULT, PCIE_AFR_COM_FTS_NUM);
889+ /* L0s and L1 entry latency */
890+ reg &= ~(PCIE_AFR_L0S_ENTRY_LATENCY | PCIE_AFR_L1_ENTRY_LATENCY);
891+ reg |= SM(PCIE_AFR_L0S_ENTRY_LATENCY_DEFAULT, PCIE_AFR_L0S_ENTRY_LATENCY)
892+ | SM(PCIE_AFR_L1_ENTRY_LATENCY_DEFAULT, PCIE_AFR_L1_ENTRY_LATENCY);
893+ IFX_REG_W32(reg, PCIE_AFR(pcie_port));
894+
895+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_AFR: 0x%08x\n",
896+ __func__, IFX_REG_R32(PCIE_AFR(pcie_port)));
897+
898+ /* Port Link Control Register */
899+ reg = IFX_REG_R32(PCIE_PLCR(pcie_port));
900+ reg |= PCIE_PLCR_DLL_LINK_EN; /* Enable the DLL link */
901+ IFX_REG_W32(reg, PCIE_PLCR(pcie_port));
902+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_PLCR: 0x%08x\n",
903+ __func__, IFX_REG_R32(PCIE_PLCR(pcie_port)));
904+
905+ /* Lane Skew Register */
906+ reg = IFX_REG_R32(PCIE_LSR(pcie_port));
907+ /* Enable ACK/NACK and FC */
908+ reg &= ~(PCIE_LSR_ACKNAK_DISABLE | PCIE_LSR_FC_DISABLE);
909+ IFX_REG_W32(reg, PCIE_LSR(pcie_port));
910+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_LSR: 0x%08x\n",
911+ __func__, IFX_REG_R32(PCIE_LSR(pcie_port)));
912+
913+ /* Symbol Timer Register and Filter Mask Register 1 */
914+ reg = IFX_REG_R32(PCIE_STRFMR(pcie_port));
915+
916+ /* Default SKP interval is very accurate already, 5us */
917+ /* Enable IO/CFG transaction */
918+ reg |= PCIE_STRFMR_RX_CFG_TRANS_ENABLE | PCIE_STRFMR_RX_IO_TRANS_ENABLE;
919+ /* Disable FC WDT */
920+ reg &= ~PCIE_STRFMR_FC_WDT_DISABLE;
921+ IFX_REG_W32(reg, PCIE_STRFMR(pcie_port));
922+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_STRFMR: 0x%08x\n",
923+ __func__, IFX_REG_R32(PCIE_STRFMR(pcie_port)));
924+
925+ /* Filter Masker Register 2 */
926+ reg = IFX_REG_R32(PCIE_FMR2(pcie_port));
927+ reg |= PCIE_FMR2_VENDOR_MSG1_PASSED_TO_TRGT1 | PCIE_FMR2_VENDOR_MSG0_PASSED_TO_TRGT1;
928+ IFX_REG_W32(reg, PCIE_FMR2(pcie_port));
929+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_FMR2: 0x%08x\n",
930+ __func__, IFX_REG_R32(PCIE_FMR2(pcie_port)));
931+
932+ /* VC0 Completion Receive Queue Control Register */
933+ reg = IFX_REG_R32(PCIE_VC0_CRQCR(pcie_port));
934+ reg &= ~PCIE_VC0_CRQCR_CPL_TLP_QUEUE_MODE;
935+ reg |= SM(PCIE_VC0_TLP_QUEUE_MODE_BYPASS, PCIE_VC0_CRQCR_CPL_TLP_QUEUE_MODE);
936+ IFX_REG_W32(reg, PCIE_VC0_CRQCR(pcie_port));
937+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_VC0_CRQCR: 0x%08x\n",
938+ __func__, IFX_REG_R32(PCIE_VC0_CRQCR(pcie_port)));
939+}
940+
941+static INLINE void
942+pcie_rc_cfg_reg_setup(int pcie_port)
943+{
944+ pcie_ltssm_disable(pcie_port);
945+ pcie_mem_io_setup(pcie_port);
946+ pcie_msi_setup(pcie_port);
947+ pcie_pm_setup(pcie_port);
948+ pcie_bus_setup(pcie_port);
949+ pcie_device_setup(pcie_port);
950+ pcie_link_setup(pcie_port);
951+ pcie_error_setup(pcie_port);
952+ pcie_root_setup(pcie_port);
953+ pcie_vc_setup(pcie_port);
954+ pcie_port_logic_setup(pcie_port);
955+}
956+
957+static int
958+ifx_pcie_wait_phy_link_up(int pcie_port)
959+{
960+#define IFX_PCIE_PHY_LINK_UP_TIMEOUT 1000 /* XXX, tunable */
961+ int i;
962+
963+ /* Wait for PHY link is up */
964+ for (i = 0; i < IFX_PCIE_PHY_LINK_UP_TIMEOUT; i++) {
965+ if (ifx_pcie_link_up(pcie_port)) {
966+ break;
967+ }
968+ udelay(100);
969+ }
970+ if (i >= IFX_PCIE_PHY_LINK_UP_TIMEOUT) {
971+ printk(KERN_ERR "%s timeout\n", __func__);
972+ return -1;
973+ }
974+
975+ /* Check data link up or not */
976+ if (!(IFX_REG_R32(PCIE_RC_DR(pcie_port)) & PCIE_RC_DR_DLL_UP)) {
977+ printk(KERN_ERR "%s DLL link is still down\n", __func__);
978+ return -1;
979+ }
980+
981+ /* Check Data link active or not */
982+ if (!(IFX_REG_R32(PCIE_LCTLSTS(pcie_port)) & PCIE_LCTLSTS_DLL_ACTIVE)) {
983+ printk(KERN_ERR "%s DLL is not active\n", __func__);
984+ return -1;
985+ }
986+ return 0;
987+#undef IFX_PCIE_PHY_LINK_UP_TIMEOUT
988+}
989+
990+static INLINE int
991+pcie_app_loigc_setup(int pcie_port)
992+{
993+#ifdef IFX_PCIE_PHY_DBG
994+ pcie_disable_scrambling(pcie_port);
995+#endif /* IFX_PCIE_PHY_DBG */
996+ pcie_ahb_bus_error_suppress(pcie_port);
997+
998+ /* Pull PCIe EP out of reset */
999+ pcie_device_rst_deassert(pcie_port);
1000+
1001+ /* Start LTSSM training between RC and EP */
1002+ pcie_ltssm_enable(pcie_port);
1003+
1004+ /* Check PHY status after enabling LTSSM */
1005+ if (ifx_pcie_wait_phy_link_up(pcie_port) != 0) {
1006+ return -1;
1007+ }
1008+ return 0;
1009+}
1010+
1011+/*
1012+ * Must be done after ltssm due to based on negotiated link
1013+ * width and payload size
1014+ * Update the Replay Time Limit. Empirically, some PCIe
1015+ * devices take a little longer to respond than expected under
1016+ * load. As a workaround for this we configure the Replay Time
1017+ * Limit to the value expected for a 512 byte MPS instead of
1018+ * our actual 128 byte MPS. The numbers below are directly
1019+ * from the PCIe spec table 3-4/5.
1020+ */
1021+static INLINE void
1022+pcie_replay_time_update(int pcie_port)
1023+{
1024+ u32 reg;
1025+ int nlw;
1026+ int rtl;
1027+
1028+ reg = IFX_REG_R32(PCIE_LCTLSTS(pcie_port));
1029+
1030+ nlw = MS(reg, PCIE_LCTLSTS_NEGOTIATED_LINK_WIDTH);
1031+ switch (nlw) {
1032+ case PCIE_MAX_LENGTH_WIDTH_X1:
1033+ rtl = 1677;
1034+ break;
1035+ case PCIE_MAX_LENGTH_WIDTH_X2:
1036+ rtl = 867;
1037+ break;
1038+ case PCIE_MAX_LENGTH_WIDTH_X4:
1039+ rtl = 462;
1040+ break;
1041+ case PCIE_MAX_LENGTH_WIDTH_X8:
1042+ rtl = 258;
1043+ break;
1044+ default:
1045+ rtl = 1677;
1046+ break;
1047+ }
1048+ reg = IFX_REG_R32(PCIE_ALTRT(pcie_port));
1049+ reg &= ~PCIE_ALTRT_REPLAY_TIME_LIMIT;
1050+ reg |= SM(rtl, PCIE_ALTRT_REPLAY_TIME_LIMIT);
1051+ IFX_REG_W32(reg, PCIE_ALTRT(pcie_port));
1052+
1053+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_ALTRT 0x%08x\n",
1054+ __func__, IFX_REG_R32(PCIE_ALTRT(pcie_port)));
1055+}
1056+
1057+/*
1058+ * Table 359 Enhanced Configuration Address Mapping1)
1059+ * 1) This table is defined in Table 7-1, page 341, PCI Express Base Specification v1.1
1060+ * Memory Address PCI Express Configuration Space
1061+ * A[(20+n-1):20] Bus Number 1 < n < 8
1062+ * A[19:15] Device Number
1063+ * A[14:12] Function Number
1064+ * A[11:8] Extended Register Number
1065+ * A[7:2] Register Number
1066+ * A[1:0] Along with size of the access, used to generate Byte Enables
1067+ * For VR9, only the address bits [22:0] are mapped to the configuration space:
1068+ * . Address bits [22:20] select the target bus (1-of-8)1)
1069+ * . Address bits [19:15] select the target device (1-of-32) on the bus
1070+ * . Address bits [14:12] select the target function (1-of-8) within the device.
1071+ * . Address bits [11:2] selects the target dword (1-of-1024) within the selected function.s configuration space
1072+ * . Address bits [1:0] define the start byte location within the selected dword.
1073+ */
1074+static inline u32
1075+pcie_bus_addr(u8 bus_num, u16 devfn, int where)
1076+{
1077+ u32 addr;
1078+ u8 bus;
1079+
1080+ if (!bus_num) {
1081+ /* type 0 */
1082+ addr = ((PCI_SLOT(devfn) & 0x1F) << 15) | ((PCI_FUNC(devfn) & 0x7) << 12) | ((where & 0xFFF)& ~3);
1083+ }
1084+ else {
1085+ bus = bus_num;
1086+ /* type 1, only support 8 buses */
1087+ addr = ((bus & 0x7) << 20) | ((PCI_SLOT(devfn) & 0x1F) << 15) |
1088+ ((PCI_FUNC(devfn) & 0x7) << 12) | ((where & 0xFFF) & ~3);
1089+ }
1090+ IFX_PCIE_PRINT(PCIE_MSG_CFG, "%s: bus addr : %02x:%02x.%01x/%02x, addr=%08x\n",
1091+ __func__, bus_num, PCI_SLOT(devfn), PCI_FUNC(devfn), where, addr);
1092+ return addr;
1093+}
1094+
1095+static int
1096+pcie_valid_config(int pcie_port, int bus, int dev)
1097+{
1098+ /* RC itself */
1099+ if ((bus == 0) && (dev == 0)) {
1100+ return 1;
1101+ }
1102+
1103+ /* No physical link */
1104+ if (!ifx_pcie_link_up(pcie_port)) {
1105+ return 0;
1106+ }
1107+
1108+ /* Bus zero only has RC itself
1109+ * XXX, check if EP will be integrated
1110+ */
1111+ if ((bus == 0) && (dev != 0)) {
1112+ return 0;
1113+ }
1114+
1115+ /* Maximum 8 buses supported for VRX */
1116+ if (bus > 9) {
1117+ return 0;
1118+ }
1119+
1120+ /*
1121+ * PCIe is PtP link, one bus only supports only one device
1122+ * except bus zero and PCIe switch which is virtual bus device
1123+ * The following two conditions really depends on the system design
1124+ * and attached the device.
1125+ * XXX, how about more new switch
1126+ */
1127+ if ((bus == 1) && (dev != 0)) {
1128+ return 0;
1129+ }
1130+
1131+ if ((bus >= 3) && (dev != 0)) {
1132+ return 0;
1133+ }
1134+ return 1;
1135+}
1136+
1137+static INLINE u32
1138+ifx_pcie_cfg_rd(int pcie_port, u32 reg)
1139+{
1140+ return IFX_REG_R32((volatile u32 *)(PCIE_CFG_PORT_TO_BASE(pcie_port) + reg));
1141+}
1142+
1143+static INLINE void
1144+ifx_pcie_cfg_wr(int pcie_port, unsigned int reg, u32 val)
1145+{
1146+ IFX_REG_W32( val, (volatile u32 *)(PCIE_CFG_PORT_TO_BASE(pcie_port) + reg));
1147+}
1148+
1149+static INLINE u32
1150+ifx_pcie_rc_cfg_rd(int pcie_port, u32 reg)
1151+{
1152+ return IFX_REG_R32((volatile u32 *)(PCIE_RC_PORT_TO_BASE(pcie_port) + reg));
1153+}
1154+
1155+static INLINE void
1156+ifx_pcie_rc_cfg_wr(int pcie_port, unsigned int reg, u32 val)
1157+{
1158+ IFX_REG_W32(val, (volatile u32 *)(PCIE_RC_PORT_TO_BASE(pcie_port) + reg));
1159+}
1160+
1161+u32
1162+ifx_pcie_bus_enum_read_hack(int where, u32 value)
1163+{
1164+ u32 tvalue = value;
1165+
1166+ if (where == PCI_PRIMARY_BUS) {
1167+ u8 primary, secondary, subordinate;
1168+
1169+ primary = tvalue & 0xFF;
1170+ secondary = (tvalue >> 8) & 0xFF;
1171+ subordinate = (tvalue >> 16) & 0xFF;
1172+ primary += pcibios_1st_host_bus_nr();
1173+ secondary += pcibios_1st_host_bus_nr();
1174+ subordinate += pcibios_1st_host_bus_nr();
1175+ tvalue = (tvalue & 0xFF000000) | (u32)primary | (u32)(secondary << 8) | (u32)(subordinate << 16);
1176+ }
1177+ return tvalue;
1178+}
1179+
1180+u32
1181+ifx_pcie_bus_enum_write_hack(int where, u32 value)
1182+{
1183+ u32 tvalue = value;
1184+
1185+ if (where == PCI_PRIMARY_BUS) {
1186+ u8 primary, secondary, subordinate;
1187+
1188+ primary = tvalue & 0xFF;
1189+ secondary = (tvalue >> 8) & 0xFF;
1190+ subordinate = (tvalue >> 16) & 0xFF;
1191+ if (primary > 0 && primary != 0xFF) {
1192+ primary -= pcibios_1st_host_bus_nr();
1193+ }
1194+
1195+ if (secondary > 0 && secondary != 0xFF) {
1196+ secondary -= pcibios_1st_host_bus_nr();
1197+ }
1198+ if (subordinate > 0 && subordinate != 0xFF) {
1199+ subordinate -= pcibios_1st_host_bus_nr();
1200+ }
1201+ tvalue = (tvalue & 0xFF000000) | (u32)primary | (u32)(secondary << 8) | (u32)(subordinate << 16);
1202+ }
1203+ else if (where == PCI_SUBORDINATE_BUS) {
1204+ u8 subordinate = tvalue & 0xFF;
1205+
1206+ subordinate = subordinate > 0 ? subordinate - pcibios_1st_host_bus_nr() : 0;
1207+ tvalue = subordinate;
1208+ }
1209+ return tvalue;
1210+}
1211+
1212+/**
1213+ * \fn static int ifx_pcie_read_config(struct pci_bus *bus, u32 devfn,
1214+ * int where, int size, u32 *value)
1215+ * \brief Read a value from configuration space
1216+ *
1217+ * \param[in] bus Pointer to pci bus
1218+ * \param[in] devfn PCI device function number
1219+ * \param[in] where PCI register number
1220+ * \param[in] size Register read size
1221+ * \param[out] value Pointer to return value
1222+ * \return PCIBIOS_BAD_REGISTER_NUMBER Invalid register number
1223+ * \return PCIBIOS_FUNC_NOT_SUPPORTED PCI function not supported
1224+ * \return PCIBIOS_DEVICE_NOT_FOUND PCI device not found
1225+ * \return PCIBIOS_SUCCESSFUL OK
1226+ * \ingroup IFX_PCIE_OS
1227+ */
1228+static int
1229+ifx_pcie_read_config(struct pci_bus *bus, u32 devfn,
1230+ int where, int size, u32 *value)
1231+{
1232+ u32 data = 0;
1233+ int bus_number = bus->number;
1234+ static const u32 mask[8] = {0, 0xff, 0xffff, 0, 0xffffffff, 0, 0, 0};
1235+ int ret = PCIBIOS_SUCCESSFUL;
1236+ struct ifx_pci_controller *ctrl = bus->sysdata;
1237+ int pcie_port = ctrl->port;
1238+
1239+ if (unlikely(size != 1 && size != 2 && size != 4)){
1240+ ret = PCIBIOS_BAD_REGISTER_NUMBER;
1241+ goto out;
1242+ }
1243+
1244+ /* Make sure the address is aligned to natural boundary */
1245+ if (unlikely(((size - 1) & where))) {
1246+ ret = PCIBIOS_BAD_REGISTER_NUMBER;
1247+ goto out;
1248+ }
1249+
1250+ /*
1251+ * If we are second controller, we have to cheat OS so that it assume
1252+ * its bus number starts from 0 in host controller
1253+ */
1254+ bus_number = ifx_pcie_bus_nr_deduct(bus_number, pcie_port);
1255+
1256+ /*
1257+ * We need to force the bus number to be zero on the root
1258+ * bus. Linux numbers the 2nd root bus to start after all
1259+ * busses on root 0.
1260+ */
1261+ if (bus->parent == NULL) {
1262+ bus_number = 0;
1263+ }
1264+
1265+ /*
1266+ * PCIe only has a single device connected to it. It is
1267+ * always device ID 0. Don't bother doing reads for other
1268+ * device IDs on the first segment.
1269+ */
1270+ if ((bus_number == 0) && (PCI_SLOT(devfn) != 0)) {
1271+ ret = PCIBIOS_FUNC_NOT_SUPPORTED;
1272+ goto out;
1273+ }
1274+
1275+ if (pcie_valid_config(pcie_port, bus_number, PCI_SLOT(devfn)) == 0) {
1276+ *value = 0xffffffff;
1277+ ret = PCIBIOS_DEVICE_NOT_FOUND;
1278+ goto out;
1279+ }
1280+
1281+ IFX_PCIE_PRINT(PCIE_MSG_READ_CFG, "%s: %02x:%02x.%01x/%02x:%01d\n", __func__, bus_number,
1282+ PCI_SLOT(devfn), PCI_FUNC(devfn), where, size);
1283+
1284+ PCIE_IRQ_LOCK(ifx_pcie_lock);
1285+ if (bus_number == 0) { /* RC itself */
1286+ u32 t;
1287+
1288+ t = (where & ~3);
1289+ data = ifx_pcie_rc_cfg_rd(pcie_port, t);
1290+ IFX_PCIE_PRINT(PCIE_MSG_READ_CFG, "%s: rd local cfg, offset:%08x, data:%08x\n",
1291+ __func__, t, data);
1292+ }
1293+ else {
1294+ u32 addr = pcie_bus_addr(bus_number, devfn, where);
1295+
1296+ data = ifx_pcie_cfg_rd(pcie_port, addr);
1297+ if (pcie_port == IFX_PCIE_PORT0) {
1298+ #ifdef CONFIG_IFX_PCIE_HW_SWAP
1299+ data = le32_to_cpu(data);
1300+ #endif /* CONFIG_IFX_PCIE_HW_SWAP */
1301+ }
1302+ else {
1303+ #ifdef CONFIG_IFX_PCIE1_HW_SWAP
1304+ data = le32_to_cpu(data);
1305+ #endif /* CONFIG_IFX_PCIE_HW_SWAP */
1306+ }
1307+ }
1308+ /* To get a correct PCI topology, we have to restore the bus number to OS */
1309+ data = ifx_pcie_bus_enum_hack(bus, devfn, where, data, pcie_port, 1);
1310+
1311+ PCIE_IRQ_UNLOCK(ifx_pcie_lock);
1312+ IFX_PCIE_PRINT(PCIE_MSG_READ_CFG, "%s: read config: data=%08x raw=%08x\n",
1313+ __func__, (data >> (8 * (where & 3))) & mask[size & 7], data);
1314+
1315+ *value = (data >> (8 * (where & 3))) & mask[size & 7];
1316+out:
1317+ return ret;
1318+}
1319+
1320+static u32
1321+ifx_pcie_size_to_value(int where, int size, u32 data, u32 value)
1322+{
1323+ u32 shift;
1324+ u32 tdata = data;
1325+
1326+ switch (size) {
1327+ case 1:
1328+ shift = (where & 0x3) << 3;
1329+ tdata &= ~(0xffU << shift);
1330+ tdata |= ((value & 0xffU) << shift);
1331+ break;
1332+ case 2:
1333+ shift = (where & 3) << 3;
1334+ tdata &= ~(0xffffU << shift);
1335+ tdata |= ((value & 0xffffU) << shift);
1336+ break;
1337+ case 4:
1338+ tdata = value;
1339+ break;
1340+ }
1341+ return tdata;
1342+}
1343+
1344+/**
1345+ * \fn static static int ifx_pcie_write_config(struct pci_bus *bus, u32 devfn,
1346+ * int where, int size, u32 value)
1347+ * \brief Write a value to PCI configuration space
1348+ *
1349+ * \param[in] bus Pointer to pci bus
1350+ * \param[in] devfn PCI device function number
1351+ * \param[in] where PCI register number
1352+ * \param[in] size The register size to be written
1353+ * \param[in] value The valule to be written
1354+ * \return PCIBIOS_BAD_REGISTER_NUMBER Invalid register number
1355+ * \return PCIBIOS_DEVICE_NOT_FOUND PCI device not found
1356+ * \return PCIBIOS_SUCCESSFUL OK
1357+ * \ingroup IFX_PCIE_OS
1358+ */
1359+static int
1360+ifx_pcie_write_config(struct pci_bus *bus, u32 devfn,
1361+ int where, int size, u32 value)
1362+{
1363+ int bus_number = bus->number;
1364+ int ret = PCIBIOS_SUCCESSFUL;
1365+ struct ifx_pci_controller *ctrl = bus->sysdata;
1366+ int pcie_port = ctrl->port;
1367+ u32 tvalue = value;
1368+ u32 data;
1369+
1370+ /* Make sure the address is aligned to natural boundary */
1371+ if (unlikely(((size - 1) & where))) {
1372+ ret = PCIBIOS_BAD_REGISTER_NUMBER;
1373+ goto out;
1374+ }
1375+ /*
1376+ * If we are second controller, we have to cheat OS so that it assume
1377+ * its bus number starts from 0 in host controller
1378+ */
1379+ bus_number = ifx_pcie_bus_nr_deduct(bus_number, pcie_port);
1380+
1381+ /*
1382+ * We need to force the bus number to be zero on the root
1383+ * bus. Linux numbers the 2nd root bus to start after all
1384+ * busses on root 0.
1385+ */
1386+ if (bus->parent == NULL) {
1387+ bus_number = 0;
1388+ }
1389+
1390+ if (pcie_valid_config(pcie_port, bus_number, PCI_SLOT(devfn)) == 0) {
1391+ ret = PCIBIOS_DEVICE_NOT_FOUND;
1392+ goto out;
1393+ }
1394+
1395+ IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG, "%s: %02x:%02x.%01x/%02x:%01d value=%08x\n", __func__,
1396+ bus_number, PCI_SLOT(devfn), PCI_FUNC(devfn), where, size, value);
1397+
1398+ /* XXX, some PCIe device may need some delay */
1399+ PCIE_IRQ_LOCK(ifx_pcie_lock);
1400+
1401+ /*
1402+ * To configure the correct bus topology using native way, we have to cheat Os so that
1403+ * it can configure the PCIe hardware correctly.
1404+ */
1405+ tvalue = ifx_pcie_bus_enum_hack(bus, devfn, where, value, pcie_port, 0);
1406+
1407+ if (bus_number == 0) { /* RC itself */
1408+ u32 t;
1409+
1410+ t = (where & ~3);
1411+ IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: wr local cfg, offset:%08x, fill:%08x\n", __func__, t, value);
1412+ data = ifx_pcie_rc_cfg_rd(pcie_port, t);
1413+ IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: rd local cfg, offset:%08x, data:%08x\n", __func__, t, data);
1414+
1415+ data = ifx_pcie_size_to_value(where, size, data, tvalue);
1416+
1417+ IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: wr local cfg, offset:%08x, value:%08x\n", __func__, t, data);
1418+ ifx_pcie_rc_cfg_wr(pcie_port, t, data);
1419+ IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: rd local cfg, offset:%08x, value:%08x\n",
1420+ __func__, t, ifx_pcie_rc_cfg_rd(pcie_port, t));
1421+ }
1422+ else {
1423+ u32 addr = pcie_bus_addr(bus_number, devfn, where);
1424+
1425+ IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: wr cfg, offset:%08x, fill:%08x\n", __func__, addr, value);
1426+ data = ifx_pcie_cfg_rd(pcie_port, addr);
1427+ if (pcie_port == IFX_PCIE_PORT0) {
1428+ #ifdef CONFIG_IFX_PCIE_HW_SWAP
1429+ data = le32_to_cpu(data);
1430+ #endif /* CONFIG_IFX_PCIE_HW_SWAP */
1431+ }
1432+ else {
1433+ #ifdef CONFIG_IFX_PCIE1_HW_SWAP
1434+ data = le32_to_cpu(data);
1435+ #endif /* CONFIG_IFX_PCIE_HW_SWAP */
1436+ }
1437+ IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: rd cfg, offset:%08x, data:%08x\n", __func__, addr, data);
1438+
1439+ data = ifx_pcie_size_to_value(where, size, data, tvalue);
1440+ if (pcie_port == IFX_PCIE_PORT0) {
1441+ #ifdef CONFIG_IFX_PCIE_HW_SWAP
1442+ data = cpu_to_le32(data);
1443+ #endif /* CONFIG_IFX_PCIE_HW_SWAP */
1444+ }
1445+ else {
1446+ #ifdef CONFIG_IFX_PCIE1_HW_SWAP
1447+ data = cpu_to_le32(data);
1448+ #endif /* CONFIG_IFX_PCIE_HW_SWAP */
1449+ }
1450+ IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG, "%s: wr cfg, offset:%08x, value:%08x\n", __func__, addr, data);
1451+ ifx_pcie_cfg_wr(pcie_port, addr, data);
1452+ IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG, "%s: rd cfg, offset:%08x, value:%08x\n",
1453+ __func__, addr, ifx_pcie_cfg_rd(pcie_port, addr));
1454+ }
1455+ PCIE_IRQ_UNLOCK(ifx_pcie_lock);
1456+out:
1457+ return ret;
1458+}
1459+
1460+static struct resource ifx_pcie_io_resource = {
1461+ .name = "PCIe0 I/O space",
1462+ .start = PCIE_IO_PHY_BASE,
1463+ .end = PCIE_IO_PHY_END,
1464+ .flags = IORESOURCE_IO,
1465+};
1466+
1467+static struct resource ifx_pcie_mem_resource = {
1468+ .name = "PCIe0 Memory space",
1469+ .start = PCIE_MEM_PHY_BASE,
1470+ .end = PCIE_MEM_PHY_END,
1471+ .flags = IORESOURCE_MEM,
1472+};
1473+
1474+static struct pci_ops ifx_pcie_ops = {
1475+ .read = ifx_pcie_read_config,
1476+ .write = ifx_pcie_write_config,
1477+};
1478+
1479+#ifdef CONFIG_IFX_PCIE_2ND_CORE
1480+static struct resource ifx_pcie1_io_resource = {
1481+ .name = "PCIe1 I/O space",
1482+ .start = PCIE1_IO_PHY_BASE,
1483+ .end = PCIE1_IO_PHY_END,
1484+ .flags = IORESOURCE_IO,
1485+};
1486+
1487+static struct resource ifx_pcie1_mem_resource = {
1488+ .name = "PCIe1 Memory space",
1489+ .start = PCIE1_MEM_PHY_BASE,
1490+ .end = PCIE1_MEM_PHY_END,
1491+ .flags = IORESOURCE_MEM,
1492+};
1493+#endif /* CONFIG_IFX_PCIE_2ND_CORE */
1494+
1495+static struct ifx_pci_controller ifx_pcie_controller[IFX_PCIE_CORE_NR] = {
1496+ {
1497+ .pcic = {
1498+ .pci_ops = &ifx_pcie_ops,
1499+ .mem_resource = &ifx_pcie_mem_resource,
1500+ .io_resource = &ifx_pcie_io_resource,
1501+ },
1502+ .port = IFX_PCIE_PORT0,
1503+ },
1504+#ifdef CONFIG_IFX_PCIE_2ND_CORE
1505+ {
1506+ .pcic = {
1507+ .pci_ops = &ifx_pcie_ops,
1508+ .mem_resource = &ifx_pcie1_mem_resource,
1509+ .io_resource = &ifx_pcie1_io_resource,
1510+ },
1511+ .port = IFX_PCIE_PORT1,
1512+ },
1513+#endif /* CONFIG_IFX_PCIE_2ND_CORE */
1514+};
1515+
1516+#ifdef IFX_PCIE_ERROR_INT
1517+static INLINE void
1518+pcie_core_int_clear_all(int pcie_port)
1519+{
1520+ u32 reg;
1521+
1522+ reg = IFX_REG_R32(PCIE_IRNCR(pcie_port));
1523+ IFX_PCIE_PRINT(PCIE_MSG_ISR, "%s PCIE_IRNCR: 0x%08x\n",
1524+ __func__, IFX_REG_R32(PCIE_IRNCR(pcie_port)));
1525+ reg &= PCIE_RC_CORE_COMBINED_INT;
1526+ IFX_REG_W32(reg, PCIE_IRNCR(pcie_port));
1527+}
1528+
1529+static irqreturn_t
1530+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
1531+pcie_rc_core_isr(int irq, void *dev_id)
1532+#else
1533+pcie_rc_core_isr(int irq, void *dev_id, struct pt_regs *regs)
1534+#endif
1535+{
1536+ struct ifx_pci_controller *ctrl = (struct ifx_pci_controller *)dev_id;
1537+ int pcie_port = ctrl->port;
1538+
1539+ IFX_PCIE_PRINT(PCIE_MSG_ISR, "PCIe RC error intr %d\n", irq);
1540+ pcie_core_int_clear_all(pcie_port);
1541+ return IRQ_HANDLED;
1542+}
1543+
1544+static int
1545+pcie_rc_core_int_init(int pcie_port)
1546+{
1547+ int ret;
1548+
1549+ IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s enter \n", __func__);
1550+
1551+ /* Enable core interrupt */
1552+ IFX_REG_SET_BIT(PCIE_RC_CORE_COMBINED_INT, PCIE_IRNEN(pcie_port));
1553+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_IRNEN: 0x%08x\n",
1554+ __func__, IFX_REG_R32(PCIE_IRNEN(pcie_port)));
1555+
1556+ /* Clear it first */
1557+ IFX_REG_SET_BIT(PCIE_RC_CORE_COMBINED_INT, PCIE_IRNCR(pcie_port));
1558+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_IRNCR: 0x%08x\n",
1559+ __func__, IFX_REG_R32(PCIE_IRNCR(pcie_port)));
1560+ ret = request_irq(pcie_irqs[pcie_port].ir_irq.irq, pcie_rc_core_isr, IRQF_DISABLED,
1561+ pcie_irqs[pcie_port].ir_irq.name, &ifx_pcie_controller[pcie_port]);
1562+ if (ret) {
1563+ printk(KERN_ERR "%s request irq %d failed\n", __func__, IFX_PCIE_IR);
1564+ }
1565+ IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s exit \n", __func__);
1566+
1567+ return ret;
1568+}
1569+#endif /* IFX_PCIE_ERROR_INT */
1570+
1571+/**
1572+ * \fn int ifx_pcie_bios_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
1573+ * \brief Map a PCI device to the appropriate interrupt line
1574+ *
1575+ * \param[in] dev The Linux PCI device structure for the device to map
1576+ * \param[in] slot The slot number for this device on __BUS 0__. Linux
1577+ * enumerates through all the bridges and figures out the
1578+ * slot on Bus 0 where this device eventually hooks to.
1579+ * \param[in] pin The PCI interrupt pin read from the device, then swizzled
1580+ * as it goes through each bridge.
1581+ * \return Interrupt number for the device
1582+ * \ingroup IFX_PCIE_OS
1583+ */
1584+int
1585+ifx_pcie_bios_map_irq(IFX_PCI_CONST struct pci_dev *dev, u8 slot, u8 pin)
1586+{
1587+ u32 irq_bit = 0;
1588+ int irq = 0;
1589+ struct ifx_pci_controller *ctrl = dev->bus->sysdata;
1590+ int pcie_port = ctrl->port;
1591+
1592+ printk("%s port %d dev %s slot %d pin %d \n", __func__, pcie_port, pci_name(dev), slot, pin);
1593+
1594+ if ((pin == PCIE_LEGACY_DISABLE) || (pin > PCIE_LEGACY_INT_MAX)) {
1595+ printk(KERN_WARNING "WARNING: dev %s: invalid interrupt pin %d\n", pci_name(dev), pin);
1596+ return -1;
1597+ }
1598+ /* Pin index so minus one */
1599+ irq_bit = pcie_irqs[pcie_port].legacy_irq[pin - 1].irq_bit;
1600+ irq = pcie_irqs[pcie_port].legacy_irq[pin - 1].irq;
1601+ IFX_REG_SET_BIT(irq_bit, PCIE_IRNEN(pcie_port));
1602+// printk("%s PCIE_IRNEN: 0x%08x\n", __func__, IFX_REG_R32(PCIE_IRNEN(pcie_port)));
1603+ IFX_REG_SET_BIT(irq_bit, PCIE_IRNCR(pcie_port));
1604+ // printk("%s PCIE_IRNCR: 0x%08x\n", __func__, IFX_REG_R32(PCIE_IRNCR(pcie_port)));
1605+ printk("%s dev %s irq %d assigned\n", __func__, pci_name(dev), irq);
1606+// printk("%s dev %s: exit\n", __func__, pci_name(dev));
1607+ return irq;
1608+}
1609+
1610+/**
1611+ * \fn int ifx_pcie_bios_plat_dev_init(struct pci_dev *dev)
1612+ * \brief Called to perform platform specific PCI setup
1613+ *
1614+ * \param[in] dev The Linux PCI device structure for the device to map
1615+ * \return OK
1616+ * \ingroup IFX_PCIE_OS
1617+ */
1618+int
1619+ifx_pcie_bios_plat_dev_init(struct pci_dev *dev)
1620+{
1621+ u16 config;
1622+#ifdef IFX_PCIE_ERROR_INT
1623+ u32 dconfig;
1624+ int pos;
1625+#endif /* IFX_PCIE_ERROR_INT */
1626+
1627+ IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s enter \n", __func__);
1628+ /* Enable reporting System errors and parity errors on all devices */
1629+ /* Enable parity checking and error reporting */
1630+ pci_read_config_word(dev, PCI_COMMAND, &config);
1631+ config |= PCI_COMMAND_PARITY | PCI_COMMAND_SERR /*| PCI_COMMAND_INVALIDATE |
1632+ PCI_COMMAND_FAST_BACK*/;
1633+ pci_write_config_word(dev, PCI_COMMAND, config);
1634+
1635+ if (dev->subordinate) {
1636+ /* Set latency timers on sub bridges */
1637+ pci_write_config_byte(dev, PCI_SEC_LATENCY_TIMER, 0x40); /* XXX, */
1638+ /* More bridge error detection */
1639+ pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &config);
1640+ config |= PCI_BRIDGE_CTL_PARITY | PCI_BRIDGE_CTL_SERR;
1641+ pci_write_config_word(dev, PCI_BRIDGE_CONTROL, config);
1642+ }
1643+#ifdef IFX_PCIE_ERROR_INT
1644+ /* Enable the PCIe normal error reporting */
1645+ pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
1646+ if (pos) {
1647+
1648+ /* Disable system error generation in response to error messages */
1649+ pci_read_config_word(dev, pos + PCI_EXP_RTCTL, &config);
1650+ config &= ~(PCI_EXP_RTCTL_SECEE | PCI_EXP_RTCTL_SENFEE | PCI_EXP_RTCTL_SEFEE);
1651+ pci_write_config_word(dev, pos + PCI_EXP_RTCTL, config);
1652+
1653+ /* Clear PCIE Capability's Device Status */
1654+ pci_read_config_word(dev, pos + PCI_EXP_DEVSTA, &config);
1655+ pci_write_config_word(dev, pos + PCI_EXP_DEVSTA, config);
1656+
1657+ /* Update Device Control */
1658+ pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &config);
1659+ /* Correctable Error Reporting */
1660+ config |= PCI_EXP_DEVCTL_CERE;
1661+ /* Non-Fatal Error Reporting */
1662+ config |= PCI_EXP_DEVCTL_NFERE;
1663+ /* Fatal Error Reporting */
1664+ config |= PCI_EXP_DEVCTL_FERE;
1665+ /* Unsupported Request */
1666+ config |= PCI_EXP_DEVCTL_URRE;
1667+ pci_write_config_word(dev, pos + PCI_EXP_DEVCTL, config);
1668+ }
1669+
1670+ /* Find the Advanced Error Reporting capability */
1671+ pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
1672+ if (pos) {
1673+ /* Clear Uncorrectable Error Status */
1674+ pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS, &dconfig);
1675+ pci_write_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS, dconfig);
1676+ /* Enable reporting of all uncorrectable errors */
1677+ /* Uncorrectable Error Mask - turned on bits disable errors */
1678+ pci_write_config_dword(dev, pos + PCI_ERR_UNCOR_MASK, 0);
1679+ /*
1680+ * Leave severity at HW default. This only controls if
1681+ * errors are reported as uncorrectable or
1682+ * correctable, not if the error is reported.
1683+ */
1684+ /* PCI_ERR_UNCOR_SEVER - Uncorrectable Error Severity */
1685+ /* Clear Correctable Error Status */
1686+ pci_read_config_dword(dev, pos + PCI_ERR_COR_STATUS, &dconfig);
1687+ pci_write_config_dword(dev, pos + PCI_ERR_COR_STATUS, dconfig);
1688+ /* Enable reporting of all correctable errors */
1689+ /* Correctable Error Mask - turned on bits disable errors */
1690+ pci_write_config_dword(dev, pos + PCI_ERR_COR_MASK, 0);
1691+ /* Advanced Error Capabilities */
1692+ pci_read_config_dword(dev, pos + PCI_ERR_CAP, &dconfig);
1693+ /* ECRC Generation Enable */
1694+ if (dconfig & PCI_ERR_CAP_ECRC_GENC) {
1695+ dconfig |= PCI_ERR_CAP_ECRC_GENE;
1696+ }
1697+ /* ECRC Check Enable */
1698+ if (dconfig & PCI_ERR_CAP_ECRC_CHKC) {
1699+ dconfig |= PCI_ERR_CAP_ECRC_CHKE;
1700+ }
1701+ pci_write_config_dword(dev, pos + PCI_ERR_CAP, dconfig);
1702+
1703+ /* PCI_ERR_HEADER_LOG - Header Log Register (16 bytes) */
1704+ /* Enable Root Port's interrupt in response to error messages */
1705+ pci_write_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND,
1706+ PCI_ERR_ROOT_CMD_COR_EN |
1707+ PCI_ERR_ROOT_CMD_NONFATAL_EN |
1708+ PCI_ERR_ROOT_CMD_FATAL_EN);
1709+ /* Clear the Root status register */
1710+ pci_read_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, &dconfig);
1711+ pci_write_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, dconfig);
1712+ }
1713+#endif /* IFX_PCIE_ERROR_INT */
1714+ /* WAR, only 128 MRRS is supported, force all EPs to support this value */
1715+ pcie_set_readrq(dev, 128);
1716+ IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s exit \n", __func__);
1717+ return 0;
1718+}
1719+
1720+static void
1721+pcie_phy_rst(int pcie_port)
1722+{
1723+ pcie_phy_rst_assert(pcie_port);
1724+ pcie_phy_rst_deassert(pcie_port);
1725+
1726+ /* Make sure PHY PLL is stable */
1727+ udelay(20);
1728+}
1729+
1730+static int
1731+pcie_rc_initialize(int pcie_port)
1732+{
1733+ int i;
1734+#define IFX_PCIE_PHY_LOOP_CNT 5
1735+
1736+ pcie_rcu_endian_setup(pcie_port);
1737+
1738+ pcie_ep_gpio_rst_init(pcie_port);
1739+
1740+ /*
1741+ * XXX, PCIe elastic buffer bug will cause not to be detected. One more
1742+ * reset PCIe PHY will solve this issue
1743+ */
1744+ for (i = 0; i < IFX_PCIE_PHY_LOOP_CNT; i++) {
1745+ /* Disable PCIe PHY Analog part for sanity check */
1746+ pcie_phy_pmu_disable(pcie_port);
1747+
1748+ pcie_phy_rst(pcie_port);
1749+
1750+ /* PCIe Core reset enabled, low active, sw programmed */
1751+ pcie_core_rst_assert(pcie_port);
1752+
1753+ /* Put PCIe EP in reset status */
1754+ pcie_device_rst_assert(pcie_port);
1755+
1756+ /* PCI PHY & Core reset disabled, high active, sw programmed */
1757+ pcie_core_rst_deassert(pcie_port);
1758+
1759+ /* Already in a quiet state, program PLL, enable PHY, check ready bit */
1760+ pcie_phy_clock_mode_setup(pcie_port);
1761+
1762+ /* Enable PCIe PHY and Clock */
1763+ pcie_core_pmu_setup(pcie_port);
1764+
1765+ /* Clear status registers */
1766+ pcie_status_register_clear(pcie_port);
1767+
1768+ #ifdef CONFIG_PCI_MSI
1769+ pcie_msi_init(pcie_port);
1770+ #endif /* CONFIG_PCI_MSI */
1771+ pcie_rc_cfg_reg_setup(pcie_port);
1772+
1773+ /* Once link is up, break out */
1774+ if (pcie_app_loigc_setup(pcie_port) == 0) {
1775+ break;
1776+ }
1777+ }
1778+ if (i >= IFX_PCIE_PHY_LOOP_CNT) {
1779+ printk(KERN_ERR "%s link up failed!!!!!\n", __func__);
1780+ return -EIO;
1781+ }
1782+ /* NB, don't increase ACK/NACK timer timeout value, which will cause a lot of COR errors */
1783+ pcie_replay_time_update(pcie_port);
1784+#ifdef IFX_PCIE_DBG
1785+ pcie_post_dump(pcie_port);
1786+ pcie_status_registers_dump(pcie_port);
1787+#endif /* IFX_PCIE_DBG */
1788+ return 0;
1789+}
1790+
1791+static int inline
1792+ifx_pcie_startup_port_nr(void)
1793+{
1794+ int pcie_port = IFX_PCIE_PORT0;
1795+
1796+#if defined (CONFIG_IFX_PCIE_1ST_CORE) && defined (CONFIG_IFX_PCIE_2ND_CORE)
1797+ pcie_port = IFX_PCIE_PORT0;
1798+#elif defined (CONFIG_IFX_PCIE_1ST_CORE)
1799+ pcie_port = IFX_PCIE_PORT0;
1800+#elif defined (CONFIG_IFX_PCIE_2ND_CORE)
1801+ pcie_port = IFX_PCIE_PORT1;
1802+#else
1803+ #error "Please choose valid PCIe Core"
1804+#endif
1805+ return pcie_port;
1806+}
1807+
1808+/**
1809+ * \fn static int __init ifx_pcie_bios_init(void)
1810+ * \brief Initialize the IFX PCIe controllers
1811+ *
1812+ * \return -EIO PCIe PHY link is not up
1813+ * \return -ENOMEM Configuration/IO space failed to map
1814+ * \return 0 OK
1815+ * \ingroup IFX_PCIE_OS
1816+ */
1817+extern int (*ltq_pci_plat_arch_init)(struct pci_dev *dev);
1818+extern int (*ltq_pci_map_irq)(const struct pci_dev *dev, u8 slot, u8 pin);
1819+
1820+static int __init
1821+ifx_pcie_bios_init(void)
1822+{
1823+ char ver_str[128] = {0};
1824+ void __iomem *io_map_base;
1825+ int pcie_port;
1826+ int startup_port;
1827+
1828+ IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s enter \n", __func__);
1829+
1830+ ltq_pci_map_irq = ifx_pcie_bios_map_irq;
1831+ ltq_pci_plat_arch_init = ifx_pcie_bios_plat_dev_init;
1832+
1833+ /* Enable AHB Master/ Slave */
1834+ pcie_ahb_pmu_setup();
1835+
1836+ startup_port = ifx_pcie_startup_port_nr();
1837+
1838+ for (pcie_port = startup_port; pcie_port < IFX_PCIE_CORE_NR; pcie_port++){
1839+ if (pcie_rc_initialize(pcie_port) == 0) {
1840+ IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s: ifx_pcie_cfg_base 0x%p\n",
1841+ __func__, PCIE_CFG_PORT_TO_BASE(pcie_port));
1842+ /* Otherwise, warning will pop up */
1843+ io_map_base = ioremap(PCIE_IO_PHY_PORT_TO_BASE(pcie_port), PCIE_IO_SIZE);
1844+ if (io_map_base == NULL) {
1845+ IFX_PCIE_PRINT(PCIE_MSG_ERR, "%s io space ioremap failed\n", __func__);
1846+ return -ENOMEM;
1847+ }
1848+ ifx_pcie_controller[pcie_port].pcic.io_map_base = (unsigned long)io_map_base;
1849+
1850+ register_pci_controller(&ifx_pcie_controller[pcie_port].pcic);
1851+ /* XXX, clear error status */
1852+
1853+ IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s: mem_resource 0x%p, io_resource 0x%p\n",
1854+ __func__, &ifx_pcie_controller[pcie_port].pcic.mem_resource,
1855+ &ifx_pcie_controller[pcie_port].pcic.io_resource);
1856+
1857+ #ifdef IFX_PCIE_ERROR_INT
1858+ pcie_rc_core_int_init(pcie_port);
1859+ #endif /* IFX_PCIE_ERROR_INT */
1860+ }
1861+ }
1862+#ifdef CONFIG_IFX_PMCU
1863+ ifx_pcie_pmcu_init();
1864+#endif /* CONFIG_IFX_PMCU */
1865+
1866+ sprintf(ver_str, "PCIe Root Complex %d.%d.%d", IFX_PCIE_VER_MAJOR, IFX_PCIE_VER_MID, IFX_PCIE_VER_MINOR);
1867+ printk(KERN_INFO "%s", ver_str);
1868+ return 0;
1869+#undef IFX_PCIE_PHY_LOOP_CNT
1870+}
1871+arch_initcall(ifx_pcie_bios_init);
1872+
1873+MODULE_LICENSE("GPL");
1874+MODULE_AUTHOR("Chuanhua.Lei@infineon.com");
1875+MODULE_SUPPORTED_DEVICE("Infineon builtin PCIe RC module");
1876+MODULE_DESCRIPTION("Infineon builtin PCIe RC driver");
1877+
1878diff --git a/arch/mips/pci/ifxmips_pcie.h b/arch/mips/pci/ifxmips_pcie.h
1879new file mode 100644
1880index 0000000..49a4d2f
1881--- /dev/null
1882+++ b/arch/mips/pci/ifxmips_pcie.h
1883@@ -0,0 +1,135 @@
1884+/******************************************************************************
1885+**
1886+** FILE NAME : ifxmips_pcie.h
1887+** PROJECT : IFX UEIP for VRX200
1888+** MODULES : PCIe module
1889+**
1890+** DATE : 02 Mar 2009
1891+** AUTHOR : Lei Chuanhua
1892+** DESCRIPTION : PCIe Root Complex Driver
1893+** COPYRIGHT : Copyright (c) 2009
1894+** Infineon Technologies AG
1895+** Am Campeon 1-12, 85579 Neubiberg, Germany
1896+**
1897+** This program is free software; you can redistribute it and/or modify
1898+** it under the terms of the GNU General Public License as published by
1899+** the Free Software Foundation; either version 2 of the License, or
1900+** (at your option) any later version.
1901+** HISTORY
1902+** $Version $Date $Author $Comment
1903+** 0.0.1 17 Mar,2009 Lei Chuanhua Initial version
1904+*******************************************************************************/
1905+#ifndef IFXMIPS_PCIE_H
1906+#define IFXMIPS_PCIE_H
1907+#include <linux/version.h>
1908+#include <linux/types.h>
1909+#include <linux/pci.h>
1910+#include <linux/interrupt.h>
1911+#include "ifxmips_pci_common.h"
1912+#include "ifxmips_pcie_reg.h"
1913+
1914+/*!
1915+ \defgroup IFX_PCIE PCI Express bus driver module
1916+ \brief PCI Express IP module support VRX200
1917+*/
1918+
1919+/*!
1920+ \defgroup IFX_PCIE_OS OS APIs
1921+ \ingroup IFX_PCIE
1922+ \brief PCIe bus driver OS interface functions
1923+*/
1924+
1925+/*!
1926+ \file ifxmips_pcie.h
1927+ \ingroup IFX_PCIE
1928+ \brief header file for PCIe module common header file
1929+*/
1930+#define PCIE_IRQ_LOCK(lock) do { \
1931+ unsigned long flags; \
1932+ spin_lock_irqsave(&(lock), flags);
1933+#define PCIE_IRQ_UNLOCK(lock) \
1934+ spin_unlock_irqrestore(&(lock), flags); \
1935+} while (0)
1936+
1937+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
1938+#define IRQF_SHARED SA_SHIRQ
1939+#endif
1940+
1941+#define PCIE_MSG_MSI 0x00000001
1942+#define PCIE_MSG_ISR 0x00000002
1943+#define PCIE_MSG_FIXUP 0x00000004
1944+#define PCIE_MSG_READ_CFG 0x00000008
1945+#define PCIE_MSG_WRITE_CFG 0x00000010
1946+#define PCIE_MSG_CFG (PCIE_MSG_READ_CFG | PCIE_MSG_WRITE_CFG)
1947+#define PCIE_MSG_REG 0x00000020
1948+#define PCIE_MSG_INIT 0x00000040
1949+#define PCIE_MSG_ERR 0x00000080
1950+#define PCIE_MSG_PHY 0x00000100
1951+#define PCIE_MSG_ANY 0x000001ff
1952+
1953+#define IFX_PCIE_PORT0 0
1954+#define IFX_PCIE_PORT1 1
1955+
1956+#ifdef CONFIG_IFX_PCIE_2ND_CORE
1957+#define IFX_PCIE_CORE_NR 2
1958+#else
1959+#define IFX_PCIE_CORE_NR 1
1960+#endif
1961+
1962+#define IFX_PCIE_ERROR_INT
1963+
1964+//#define IFX_PCIE_DBG
1965+
1966+#if defined(IFX_PCIE_DBG)
1967+#define IFX_PCIE_PRINT(_m, _fmt, args...) do { \
1968+ ifx_pcie_debug((_fmt), ##args); \
1969+} while (0)
1970+
1971+#define INLINE
1972+#else
1973+#define IFX_PCIE_PRINT(_m, _fmt, args...) \
1974+ do {} while(0)
1975+#define INLINE inline
1976+#endif
1977+
1978+struct ifx_pci_controller {
1979+ struct pci_controller pcic;
1980+
1981+ /* RC specific, per host bus information */
1982+ u32 port; /* Port index, 0 -- 1st core, 1 -- 2nd core */
1983+};
1984+
1985+typedef struct ifx_pcie_ir_irq {
1986+ const unsigned int irq;
1987+ const char name[16];
1988+}ifx_pcie_ir_irq_t;
1989+
1990+typedef struct ifx_pcie_legacy_irq{
1991+ const u32 irq_bit;
1992+ const int irq;
1993+}ifx_pcie_legacy_irq_t;
1994+
1995+typedef struct ifx_pcie_irq {
1996+ ifx_pcie_ir_irq_t ir_irq;
1997+ ifx_pcie_legacy_irq_t legacy_irq[PCIE_LEGACY_INT_MAX];
1998+}ifx_pcie_irq_t;
1999+
2000+extern u32 g_pcie_debug_flag;
2001+extern void ifx_pcie_debug(const char *fmt, ...);
2002+extern void pcie_phy_clock_mode_setup(int pcie_port);
2003+extern void pcie_msi_pic_init(int pcie_port);
2004+extern u32 ifx_pcie_bus_enum_read_hack(int where, u32 value);
2005+extern u32 ifx_pcie_bus_enum_write_hack(int where, u32 value);
2006+
2007+#define CONFIG_VR9
2008+
2009+#ifdef CONFIG_VR9
2010+#include "ifxmips_pcie_vr9.h"
2011+#elif defined (CONFIG_AR10)
2012+#include "ifxmips_pcie_ar10.h"
2013+#else
2014+#error "PCIE: platform not defined"
2015+#endif /* CONFIG_VR9 */
2016+
2017+#endif /* IFXMIPS_PCIE_H */
2018+
2019diff --git a/arch/mips/pci/ifxmips_pcie_ar10.h b/arch/mips/pci/ifxmips_pcie_ar10.h
2020new file mode 100644
2021index 0000000..99ff463
2022--- /dev/null
2023+++ b/arch/mips/pci/ifxmips_pcie_ar10.h
2024@@ -0,0 +1,290 @@
2025+/****************************************************************************
2026+ Copyright (c) 2010
2027+ Lantiq Deutschland GmbH
2028+ Am Campeon 3; 85579 Neubiberg, Germany
2029+
2030+ For licensing information, see the file 'LICENSE' in the root folder of
2031+ this software module.
2032+
2033+ *****************************************************************************/
2034+/*!
2035+ \file ifxmips_pcie_ar10.h
2036+ \ingroup IFX_PCIE
2037+ \brief PCIe RC driver ar10 specific file
2038+*/
2039+
2040+#ifndef IFXMIPS_PCIE_AR10_H
2041+#define IFXMIPS_PCIE_AR10_H
2042+#ifndef AUTOCONF_INCLUDED
2043+#include <linux/config.h>
2044+#endif /* AUTOCONF_INCLUDED */
2045+#include <linux/types.h>
2046+#include <linux/delay.h>
2047+
2048+/* Project header file */
2049+#include <asm/ifx/ifx_types.h>
2050+#include <asm/ifx/ifx_pmu.h>
2051+#include <asm/ifx/ifx_gpio.h>
2052+#include <asm/ifx/ifx_ebu_led.h>
2053+
2054+static inline void pcie_ep_gpio_rst_init(int pcie_port)
2055+{
2056+ ifx_ebu_led_enable();
2057+ if (pcie_port == 0) {
2058+ ifx_ebu_led_set_data(11, 1);
2059+ }
2060+ else {
2061+ ifx_ebu_led_set_data(12, 1);
2062+ }
2063+}
2064+
2065+static inline void pcie_ahb_pmu_setup(void)
2066+{
2067+ /* XXX, moved to CGU to control AHBM */
2068+}
2069+
2070+static inline void pcie_rcu_endian_setup(int pcie_port)
2071+{
2072+ u32 reg;
2073+
2074+ reg = IFX_REG_R32(IFX_RCU_AHB_ENDIAN);
2075+ /* Inbound, big endian */
2076+ reg |= IFX_RCU_BE_AHB4S;
2077+ if (pcie_port == 0) {
2078+ reg |= IFX_RCU_BE_PCIE0M;
2079+
2080+ #ifdef CONFIG_IFX_PCIE_HW_SWAP
2081+ /* Outbound, software swap needed */
2082+ reg |= IFX_RCU_BE_AHB3M;
2083+ reg &= ~IFX_RCU_BE_PCIE0S;
2084+ #else
2085+ /* Outbound little endian */
2086+ reg &= ~IFX_RCU_BE_AHB3M;
2087+ reg &= ~IFX_RCU_BE_PCIE0S;
2088+ #endif
2089+ }
2090+ else {
2091+ reg |= IFX_RCU_BE_PCIE1M;
2092+ #ifdef CONFIG_IFX_PCIE1_HW_SWAP
2093+ /* Outbound, software swap needed */
2094+ reg |= IFX_RCU_BE_AHB3M;
2095+ reg &= ~IFX_RCU_BE_PCIE1S;
2096+ #else
2097+ /* Outbound little endian */
2098+ reg &= ~IFX_RCU_BE_AHB3M;
2099+ reg &= ~IFX_RCU_BE_PCIE1S;
2100+ #endif
2101+ }
2102+
2103+ IFX_REG_W32(reg, IFX_RCU_AHB_ENDIAN);
2104+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s IFX_RCU_AHB_ENDIAN: 0x%08x\n", __func__, IFX_REG_R32(IFX_RCU_AHB_ENDIAN));
2105+}
2106+
2107+static inline void pcie_phy_pmu_enable(int pcie_port)
2108+{
2109+ if (pcie_port == 0) { /* XXX, should use macro*/
2110+ PCIE0_PHY_PMU_SETUP(IFX_PMU_ENABLE);
2111+ }
2112+ else {
2113+ PCIE1_PHY_PMU_SETUP(IFX_PMU_ENABLE);
2114+ }
2115+}
2116+
2117+static inline void pcie_phy_pmu_disable(int pcie_port)
2118+{
2119+ if (pcie_port == 0) { /* XXX, should use macro*/
2120+ PCIE0_PHY_PMU_SETUP(IFX_PMU_DISABLE);
2121+ }
2122+ else {
2123+ PCIE1_PHY_PMU_SETUP(IFX_PMU_DISABLE);
2124+ }
2125+}
2126+
2127+static inline void pcie_pdi_big_endian(int pcie_port)
2128+{
2129+ u32 reg;
2130+
2131+ reg = IFX_REG_R32(IFX_RCU_AHB_ENDIAN);
2132+ if (pcie_port == 0) {
2133+ /* Config AHB->PCIe and PDI endianness */
2134+ reg |= IFX_RCU_BE_PCIE0_PDI;
2135+ }
2136+ else {
2137+ /* Config AHB->PCIe and PDI endianness */
2138+ reg |= IFX_RCU_BE_PCIE1_PDI;
2139+ }
2140+ IFX_REG_W32(reg, IFX_RCU_AHB_ENDIAN);
2141+}
2142+
2143+static inline void pcie_pdi_pmu_enable(int pcie_port)
2144+{
2145+ if (pcie_port == 0) {
2146+ /* Enable PDI to access PCIe PHY register */
2147+ PDI0_PMU_SETUP(IFX_PMU_ENABLE);
2148+ }
2149+ else {
2150+ PDI1_PMU_SETUP(IFX_PMU_ENABLE);
2151+ }
2152+}
2153+
2154+static inline void pcie_core_rst_assert(int pcie_port)
2155+{
2156+ u32 reg;
2157+
2158+ reg = IFX_REG_R32(IFX_RCU_RST_REQ);
2159+
2160+ /* Reset Core, bit 22 */
2161+ if (pcie_port == 0) {
2162+ reg |= 0x00400000;
2163+ }
2164+ else {
2165+ reg |= 0x08000000; /* Bit 27 */
2166+ }
2167+ IFX_REG_W32(reg, IFX_RCU_RST_REQ);
2168+}
2169+
2170+static inline void pcie_core_rst_deassert(int pcie_port)
2171+{
2172+ u32 reg;
2173+
2174+ /* Make sure one micro-second delay */
2175+ udelay(1);
2176+
2177+ reg = IFX_REG_R32(IFX_RCU_RST_REQ);
2178+ if (pcie_port == 0) {
2179+ reg &= ~0x00400000; /* bit 22 */
2180+ }
2181+ else {
2182+ reg &= ~0x08000000; /* Bit 27 */
2183+ }
2184+ IFX_REG_W32(reg, IFX_RCU_RST_REQ);
2185+}
2186+
2187+static inline void pcie_phy_rst_assert(int pcie_port)
2188+{
2189+ u32 reg;
2190+
2191+ reg = IFX_REG_R32(IFX_RCU_RST_REQ);
2192+ if (pcie_port == 0) {
2193+ reg |= 0x00001000; /* Bit 12 */
2194+ }
2195+ else {
2196+ reg |= 0x00002000; /* Bit 13 */
2197+ }
2198+ IFX_REG_W32(reg, IFX_RCU_RST_REQ);
2199+}
2200+
2201+static inline void pcie_phy_rst_deassert(int pcie_port)
2202+{
2203+ u32 reg;
2204+
2205+ /* Make sure one micro-second delay */
2206+ udelay(1);
2207+
2208+ reg = IFX_REG_R32(IFX_RCU_RST_REQ);
2209+ if (pcie_port == 0) {
2210+ reg &= ~0x00001000; /* Bit 12 */
2211+ }
2212+ else {
2213+ reg &= ~0x00002000; /* Bit 13 */
2214+ }
2215+ IFX_REG_W32(reg, IFX_RCU_RST_REQ);
2216+}
2217+
2218+static inline void pcie_device_rst_assert(int pcie_port)
2219+{
2220+ if (pcie_port == 0) {
2221+ ifx_ebu_led_set_data(11, 0);
2222+ }
2223+ else {
2224+ ifx_ebu_led_set_data(12, 0);
2225+ }
2226+}
2227+
2228+static inline void pcie_device_rst_deassert(int pcie_port)
2229+{
2230+ mdelay(100);
2231+ if (pcie_port == 0) {
2232+ ifx_ebu_led_set_data(11, 1);
2233+ }
2234+ else {
2235+ ifx_ebu_led_set_data(12, 1);
2236+ }
2237+ ifx_ebu_led_disable();
2238+}
2239+
2240+static inline void pcie_core_pmu_setup(int pcie_port)
2241+{
2242+ if (pcie_port == 0) {
2243+ PCIE0_CTRL_PMU_SETUP(IFX_PMU_ENABLE);
2244+ }
2245+ else {
2246+ PCIE1_CTRL_PMU_SETUP(IFX_PMU_ENABLE);
2247+ }
2248+}
2249+
2250+static inline void pcie_msi_init(int pcie_port)
2251+{
2252+ pcie_msi_pic_init(pcie_port);
2253+ if (pcie_port == 0) {
2254+ MSI0_PMU_SETUP(IFX_PMU_ENABLE);
2255+ }
2256+ else {
2257+ MSI1_PMU_SETUP(IFX_PMU_ENABLE);
2258+ }
2259+}
2260+
2261+static inline u32
2262+ifx_pcie_bus_nr_deduct(u32 bus_number, int pcie_port)
2263+{
2264+ u32 tbus_number = bus_number;
2265+
2266+#ifdef CONFIG_IFX_PCIE_2ND_CORE
2267+ if (pcie_port == IFX_PCIE_PORT1) { /* Port 1 must check if there are two cores enabled */
2268+ if (pcibios_host_nr() > 1) {
2269+ tbus_number -= pcibios_1st_host_bus_nr();
2270+ }
2271+ }
2272+#endif /* CONFIG_IFX_PCI */
2273+ return tbus_number;
2274+}
2275+
2276+static inline u32
2277+ifx_pcie_bus_enum_hack(struct pci_bus *bus, u32 devfn, int where, u32 value, int pcie_port, int read)
2278+{
2279+ struct pci_dev *pdev;
2280+ u32 tvalue = value;
2281+
2282+ /* Sanity check */
2283+ pdev = pci_get_slot(bus, devfn);
2284+ if (pdev == NULL) {
2285+ return tvalue;
2286+ }
2287+
2288+ /* Only care about PCI bridge */
2289+ if (pdev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
2290+ return tvalue;
2291+ }
2292+
2293+ if (read) { /* Read hack */
2294+ #ifdef CONFIG_IFX_PCIE_2ND_CORE
2295+ if (pcie_port == IFX_PCIE_PORT1) { /* Port 1 must check if there are two cores enabled */
2296+ if (pcibios_host_nr() > 1) {
2297+ tvalue = ifx_pcie_bus_enum_read_hack(where, tvalue);
2298+ }
2299+ }
2300+ #endif /* CONFIG_IFX_PCIE_2ND_CORE */
2301+ }
2302+ else { /* Write hack */
2303+ #ifdef CONFIG_IFX_PCIE_2ND_CORE
2304+ if (pcie_port == IFX_PCIE_PORT1) { /* Port 1 must check if there are two cores enabled */
2305+ if (pcibios_host_nr() > 1) {
2306+ tvalue = ifx_pcie_bus_enum_write_hack(where, tvalue);
2307+ }
2308+ }
2309+ #endif
2310+ }
2311+ return tvalue;
2312+}
2313+
2314+#endif /* IFXMIPS_PCIE_AR10_H */
2315diff --git a/arch/mips/pci/ifxmips_pcie_msi.c b/arch/mips/pci/ifxmips_pcie_msi.c
2316new file mode 100644
2317index 0000000..5bee7f8
2318--- /dev/null
2319+++ b/arch/mips/pci/ifxmips_pcie_msi.c
2320@@ -0,0 +1,392 @@
2321+/******************************************************************************
2322+**
2323+** FILE NAME : ifxmips_pcie_msi.c
2324+** PROJECT : IFX UEIP for VRX200
2325+** MODULES : PCI MSI sub module
2326+**
2327+** DATE : 02 Mar 2009
2328+** AUTHOR : Lei Chuanhua
2329+** DESCRIPTION : PCIe MSI Driver
2330+** COPYRIGHT : Copyright (c) 2009
2331+** Infineon Technologies AG
2332+** Am Campeon 1-12, 85579 Neubiberg, Germany
2333+**
2334+** This program is free software; you can redistribute it and/or modify
2335+** it under the terms of the GNU General Public License as published by
2336+** the Free Software Foundation; either version 2 of the License, or
2337+** (at your option) any later version.
2338+** HISTORY
2339+** $Date $Author $Comment
2340+** 02 Mar,2009 Lei Chuanhua Initial version
2341+*******************************************************************************/
2342+/*!
2343+ \defgroup IFX_PCIE_MSI MSI OS APIs
2344+ \ingroup IFX_PCIE
2345+ \brief PCIe bus driver OS interface functions
2346+*/
2347+
2348+/*!
2349+ \file ifxmips_pcie_msi.c
2350+ \ingroup IFX_PCIE
2351+ \brief PCIe MSI OS interface file
2352+*/
2353+
2354+#ifndef AUTOCONF_INCLUDED
2355+#include <linux/config.h>
2356+#endif /* AUTOCONF_INCLUDED */
2357+#include <linux/init.h>
2358+#include <linux/sched.h>
2359+#include <linux/slab.h>
2360+#include <linux/interrupt.h>
2361+#include <linux/kernel_stat.h>
2362+#include <linux/pci.h>
2363+#include <linux/msi.h>
2364+#include <linux/module.h>
2365+#include <asm/bootinfo.h>
2366+#include <asm/irq.h>
2367+#include <asm/traps.h>
2368+
2369+#include <asm/ifx/ifx_types.h>
2370+#include <asm/ifx/ifx_regs.h>
2371+#include <asm/ifx/common_routines.h>
2372+#include <asm/ifx/irq.h>
2373+
2374+#include "ifxmips_pcie_reg.h"
2375+#include "ifxmips_pcie.h"
2376+
2377+#define IFX_MSI_IRQ_NUM 16
2378+
2379+enum {
2380+ IFX_PCIE_MSI_IDX0 = 0,
2381+ IFX_PCIE_MSI_IDX1,
2382+ IFX_PCIE_MSI_IDX2,
2383+ IFX_PCIE_MSI_IDX3,
2384+};
2385+
2386+typedef struct ifx_msi_irq_idx {
2387+ const int irq;
2388+ const int idx;
2389+}ifx_msi_irq_idx_t;
2390+
2391+struct ifx_msi_pic {
2392+ volatile u32 pic_table[IFX_MSI_IRQ_NUM];
2393+ volatile u32 pic_endian; /* 0x40 */
2394+};
2395+typedef struct ifx_msi_pic *ifx_msi_pic_t;
2396+
2397+typedef struct ifx_msi_irq {
2398+ const volatile ifx_msi_pic_t msi_pic_p;
2399+ const u32 msi_phy_base;
2400+ const ifx_msi_irq_idx_t msi_irq_idx[IFX_MSI_IRQ_NUM];
2401+ /*
2402+ * Each bit in msi_free_irq_bitmask represents a MSI interrupt that is
2403+ * in use.
2404+ */
2405+ u16 msi_free_irq_bitmask;
2406+
2407+ /*
2408+ * Each bit in msi_multiple_irq_bitmask tells that the device using
2409+ * this bit in msi_free_irq_bitmask is also using the next bit. This
2410+ * is used so we can disable all of the MSI interrupts when a device
2411+ * uses multiple.
2412+ */
2413+ u16 msi_multiple_irq_bitmask;
2414+}ifx_msi_irq_t;
2415+
2416+static ifx_msi_irq_t msi_irqs[IFX_PCIE_CORE_NR] = {
2417+ {
2418+ .msi_pic_p = (const volatile ifx_msi_pic_t)IFX_MSI_PIC_REG_BASE,
2419+ .msi_phy_base = PCIE_MSI_PHY_BASE,
2420+ .msi_irq_idx = {
2421+ {IFX_PCIE_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE_MSI_IR1, IFX_PCIE_MSI_IDX1},
2422+ {IFX_PCIE_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE_MSI_IR3, IFX_PCIE_MSI_IDX3},
2423+ {IFX_PCIE_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE_MSI_IR1, IFX_PCIE_MSI_IDX1},
2424+ {IFX_PCIE_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE_MSI_IR3, IFX_PCIE_MSI_IDX3},
2425+ {IFX_PCIE_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE_MSI_IR1, IFX_PCIE_MSI_IDX1},
2426+ {IFX_PCIE_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE_MSI_IR3, IFX_PCIE_MSI_IDX3},
2427+ {IFX_PCIE_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE_MSI_IR1, IFX_PCIE_MSI_IDX1},
2428+ {IFX_PCIE_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE_MSI_IR3, IFX_PCIE_MSI_IDX3},
2429+ },
2430+ .msi_free_irq_bitmask = 0,
2431+ .msi_multiple_irq_bitmask= 0,
2432+ },
2433+#ifdef CONFIG_IFX_PCIE_2ND_CORE
2434+ {
2435+ .msi_pic_p = (const volatile ifx_msi_pic_t)IFX_MSI1_PIC_REG_BASE,
2436+ .msi_phy_base = PCIE1_MSI_PHY_BASE,
2437+ .msi_irq_idx = {
2438+ {IFX_PCIE1_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE1_MSI_IR1, IFX_PCIE_MSI_IDX1},
2439+ {IFX_PCIE1_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE1_MSI_IR3, IFX_PCIE_MSI_IDX3},
2440+ {IFX_PCIE1_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE1_MSI_IR1, IFX_PCIE_MSI_IDX1},
2441+ {IFX_PCIE1_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE1_MSI_IR3, IFX_PCIE_MSI_IDX3},
2442+ {IFX_PCIE1_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE1_MSI_IR1, IFX_PCIE_MSI_IDX1},
2443+ {IFX_PCIE1_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE1_MSI_IR3, IFX_PCIE_MSI_IDX3},
2444+ {IFX_PCIE1_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE1_MSI_IR1, IFX_PCIE_MSI_IDX1},
2445+ {IFX_PCIE1_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE1_MSI_IR3, IFX_PCIE_MSI_IDX3},
2446+ },
2447+ .msi_free_irq_bitmask = 0,
2448+ .msi_multiple_irq_bitmask= 0,
2449+
2450+ },
2451+#endif /* CONFIG_IFX_PCIE_2ND_CORE */
2452+};
2453+
2454+/*
2455+ * This lock controls updates to msi_free_irq_bitmask,
2456+ * msi_multiple_irq_bitmask and pic register settting
2457+ */
2458+static DEFINE_SPINLOCK(ifx_pcie_msi_lock);
2459+
2460+void pcie_msi_pic_init(int pcie_port)
2461+{
2462+ spin_lock(&ifx_pcie_msi_lock);
2463+ msi_irqs[pcie_port].msi_pic_p->pic_endian = IFX_MSI_PIC_BIG_ENDIAN;
2464+ spin_unlock(&ifx_pcie_msi_lock);
2465+}
2466+
2467+/**
2468+ * \fn int arch_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
2469+ * \brief Called when a driver request MSI interrupts instead of the
2470+ * legacy INT A-D. This routine will allocate multiple interrupts
2471+ * for MSI devices that support them. A device can override this by
2472+ * programming the MSI control bits [6:4] before calling
2473+ * pci_enable_msi().
2474+ *
2475+ * \param[in] pdev Device requesting MSI interrupts
2476+ * \param[in] desc MSI descriptor
2477+ *
2478+ * \return -EINVAL Invalid pcie root port or invalid msi bit
2479+ * \return 0 OK
2480+ * \ingroup IFX_PCIE_MSI
2481+ */
2482+int
2483+arch_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
2484+{
2485+ int irq, pos;
2486+ u16 control;
2487+ int irq_idx;
2488+ int irq_step;
2489+ int configured_private_bits;
2490+ int request_private_bits;
2491+ struct msi_msg msg;
2492+ u16 search_mask;
2493+ struct ifx_pci_controller *ctrl = pdev->bus->sysdata;
2494+ int pcie_port = ctrl->port;
2495+
2496+ IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s %s enter\n", __func__, pci_name(pdev));
2497+
2498+ /* XXX, skip RC MSI itself */
2499+ if (pdev->pcie_type == PCI_EXP_TYPE_ROOT_PORT) {
2500+ IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s RC itself doesn't use MSI interrupt\n", __func__);
2501+ return -EINVAL;
2502+ }
2503+
2504+ /*
2505+ * Read the MSI config to figure out how many IRQs this device
2506+ * wants. Most devices only want 1, which will give
2507+ * configured_private_bits and request_private_bits equal 0.
2508+ */
2509+ pci_read_config_word(pdev, desc->msi_attrib.pos + PCI_MSI_FLAGS, &control);
2510+
2511+ /*
2512+ * If the number of private bits has been configured then use
2513+ * that value instead of the requested number. This gives the
2514+ * driver the chance to override the number of interrupts
2515+ * before calling pci_enable_msi().
2516+ */
2517+ configured_private_bits = (control & PCI_MSI_FLAGS_QSIZE) >> 4;
2518+ if (configured_private_bits == 0) {
2519+ /* Nothing is configured, so use the hardware requested size */
2520+ request_private_bits = (control & PCI_MSI_FLAGS_QMASK) >> 1;
2521+ }
2522+ else {
2523+ /*
2524+ * Use the number of configured bits, assuming the
2525+ * driver wanted to override the hardware request
2526+ * value.
2527+ */
2528+ request_private_bits = configured_private_bits;
2529+ }
2530+
2531+ /*
2532+ * The PCI 2.3 spec mandates that there are at most 32
2533+ * interrupts. If this device asks for more, only give it one.
2534+ */
2535+ if (request_private_bits > 5) {
2536+ request_private_bits = 0;
2537+ }
2538+again:
2539+ /*
2540+ * The IRQs have to be aligned on a power of two based on the
2541+ * number being requested.
2542+ */
2543+ irq_step = (1 << request_private_bits);
2544+
2545+ /* Mask with one bit for each IRQ */
2546+ search_mask = (1 << irq_step) - 1;
2547+
2548+ /*
2549+ * We're going to search msi_free_irq_bitmask_lock for zero
2550+ * bits. This represents an MSI interrupt number that isn't in
2551+ * use.
2552+ */
2553+ spin_lock(&ifx_pcie_msi_lock);
2554+ for (pos = 0; pos < IFX_MSI_IRQ_NUM; pos += irq_step) {
2555+ if ((msi_irqs[pcie_port].msi_free_irq_bitmask & (search_mask << pos)) == 0) {
2556+ msi_irqs[pcie_port].msi_free_irq_bitmask |= search_mask << pos;
2557+ msi_irqs[pcie_port].msi_multiple_irq_bitmask |= (search_mask >> 1) << pos;
2558+ break;
2559+ }
2560+ }
2561+ spin_unlock(&ifx_pcie_msi_lock);
2562+
2563+ /* Make sure the search for available interrupts didn't fail */
2564+ if (pos >= IFX_MSI_IRQ_NUM) {
2565+ if (request_private_bits) {
2566+ IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s: Unable to find %d free "
2567+ "interrupts, trying just one", __func__, 1 << request_private_bits);
2568+ request_private_bits = 0;
2569+ goto again;
2570+ }
2571+ else {
2572+ printk(KERN_ERR "%s: Unable to find a free MSI interrupt\n", __func__);
2573+ return -EINVAL;
2574+ }
2575+ }
2576+ irq = msi_irqs[pcie_port].msi_irq_idx[pos].irq;
2577+ irq_idx = msi_irqs[pcie_port].msi_irq_idx[pos].idx;
2578+
2579+ IFX_PCIE_PRINT(PCIE_MSG_MSI, "pos %d, irq %d irq_idx %d\n", pos, irq, irq_idx);
2580+
2581+ /*
2582+ * Initialize MSI. This has to match the memory-write endianess from the device
2583+ * Address bits [23:12]
2584+ */
2585+ spin_lock(&ifx_pcie_msi_lock);
2586+ msi_irqs[pcie_port].msi_pic_p->pic_table[pos] = SM(irq_idx, IFX_MSI_PIC_INT_LINE) |
2587+ SM((msi_irqs[pcie_port].msi_phy_base >> 12), IFX_MSI_PIC_MSG_ADDR) |
2588+ SM((1 << pos), IFX_MSI_PIC_MSG_DATA);
2589+
2590+ /* Enable this entry */
2591+ msi_irqs[pcie_port].msi_pic_p->pic_table[pos] &= ~IFX_MSI_PCI_INT_DISABLE;
2592+ spin_unlock(&ifx_pcie_msi_lock);
2593+
2594+ IFX_PCIE_PRINT(PCIE_MSG_MSI, "pic_table[%d]: 0x%08x\n",
2595+ pos, msi_irqs[pcie_port].msi_pic_p->pic_table[pos]);
2596+
2597+ /* Update the number of IRQs the device has available to it */
2598+ control &= ~PCI_MSI_FLAGS_QSIZE;
2599+ control |= (request_private_bits << 4);
2600+ pci_write_config_word(pdev, desc->msi_attrib.pos + PCI_MSI_FLAGS, control);
2601+
2602+ set_irq_msi(irq, desc);
2603+ msg.address_hi = 0x0;
2604+ msg.address_lo = msi_irqs[pcie_port].msi_phy_base;
2605+ msg.data = SM((1 << pos), IFX_MSI_PIC_MSG_DATA);
2606+ IFX_PCIE_PRINT(PCIE_MSG_MSI, "msi_data: pos %d 0x%08x\n", pos, msg.data);
2607+
2608+ write_msi_msg(irq, &msg);
2609+ IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s exit\n", __func__);
2610+ return 0;
2611+}
2612+
2613+static int
2614+pcie_msi_irq_to_port(unsigned int irq, int *port)
2615+{
2616+ int ret = 0;
2617+
2618+ if (irq == IFX_PCIE_MSI_IR0 || irq == IFX_PCIE_MSI_IR1 ||
2619+ irq == IFX_PCIE_MSI_IR2 || irq == IFX_PCIE_MSI_IR3) {
2620+ *port = IFX_PCIE_PORT0;
2621+ }
2622+#ifdef CONFIG_IFX_PCIE_2ND_CORE
2623+ else if (irq == IFX_PCIE1_MSI_IR0 || irq == IFX_PCIE1_MSI_IR1 ||
2624+ irq == IFX_PCIE1_MSI_IR2 || irq == IFX_PCIE1_MSI_IR3) {
2625+ *port = IFX_PCIE_PORT1;
2626+ }
2627+#endif /* CONFIG_IFX_PCIE_2ND_CORE */
2628+ else {
2629+ printk(KERN_ERR "%s: Attempted to teardown illegal "
2630+ "MSI interrupt (%d)\n", __func__, irq);
2631+ ret = -EINVAL;
2632+ }
2633+ return ret;
2634+}
2635+
2636+/**
2637+ * \fn void arch_teardown_msi_irq(unsigned int irq)
2638+ * \brief Called when a device no longer needs its MSI interrupts. All
2639+ * MSI interrupts for the device are freed.
2640+ *
2641+ * \param irq The devices first irq number. There may be multple in sequence.
2642+ * \return none
2643+ * \ingroup IFX_PCIE_MSI
2644+ */
2645+void
2646+arch_teardown_msi_irq(unsigned int irq)
2647+{
2648+ int pos;
2649+ int number_irqs;
2650+ u16 bitmask;
2651+ int pcie_port;
2652+
2653+ IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s enter\n", __func__);
2654+
2655+ BUG_ON(irq > INT_NUM_IM4_IRL31);
2656+
2657+ if (pcie_msi_irq_to_port(irq, &pcie_port) != 0) {
2658+ return;
2659+ }
2660+
2661+ /* Shift the mask to the correct bit location, not always correct
2662+ * Probally, the first match will be chosen.
2663+ */
2664+ for (pos = 0; pos < IFX_MSI_IRQ_NUM; pos++) {
2665+ if ((msi_irqs[pcie_port].msi_irq_idx[pos].irq == irq)
2666+ && (msi_irqs[pcie_port].msi_free_irq_bitmask & ( 1 << pos))) {
2667+ break;
2668+ }
2669+ }
2670+ if (pos >= IFX_MSI_IRQ_NUM) {
2671+ printk(KERN_ERR "%s: Unable to find a matched MSI interrupt\n", __func__);
2672+ return;
2673+ }
2674+ spin_lock(&ifx_pcie_msi_lock);
2675+ /* Disable this entry */
2676+ msi_irqs[pcie_port].msi_pic_p->pic_table[pos] |= IFX_MSI_PCI_INT_DISABLE;
2677+ msi_irqs[pcie_port].msi_pic_p->pic_table[pos] &= ~(IFX_MSI_PIC_INT_LINE | IFX_MSI_PIC_MSG_ADDR | IFX_MSI_PIC_MSG_DATA);
2678+ spin_unlock(&ifx_pcie_msi_lock);
2679+ /*
2680+ * Count the number of IRQs we need to free by looking at the
2681+ * msi_multiple_irq_bitmask. Each bit set means that the next
2682+ * IRQ is also owned by this device.
2683+ */
2684+ number_irqs = 0;
2685+ while (((pos + number_irqs) < IFX_MSI_IRQ_NUM) &&
2686+ (msi_irqs[pcie_port].msi_multiple_irq_bitmask & (1 << (pos + number_irqs)))) {
2687+ number_irqs++;
2688+ }
2689+ number_irqs++;
2690+
2691+ /* Mask with one bit for each IRQ */
2692+ bitmask = (1 << number_irqs) - 1;
2693+
2694+ bitmask <<= pos;
2695+ if ((msi_irqs[pcie_port].msi_free_irq_bitmask & bitmask) != bitmask) {
2696+ printk(KERN_ERR "%s: Attempted to teardown MSI "
2697+ "interrupt (%d) not in use\n", __func__, irq);
2698+ return;
2699+ }
2700+ /* Checks are done, update the in use bitmask */
2701+ spin_lock(&ifx_pcie_msi_lock);
2702+ msi_irqs[pcie_port].msi_free_irq_bitmask &= ~bitmask;
2703+ msi_irqs[pcie_port].msi_multiple_irq_bitmask &= ~(bitmask >> 1);
2704+ spin_unlock(&ifx_pcie_msi_lock);
2705+ IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s exit\n", __func__);
2706+}
2707+
2708+MODULE_LICENSE("GPL");
2709+MODULE_AUTHOR("Chuanhua.Lei@infineon.com");
2710+MODULE_SUPPORTED_DEVICE("Infineon PCIe IP builtin MSI PIC module");
2711+MODULE_DESCRIPTION("Infineon PCIe IP builtin MSI PIC driver");
2712+
2713diff --git a/arch/mips/pci/ifxmips_pcie_phy.c b/arch/mips/pci/ifxmips_pcie_phy.c
2714new file mode 100644
2715index 0000000..a4171a7
2716--- /dev/null
2717+++ b/arch/mips/pci/ifxmips_pcie_phy.c
2718@@ -0,0 +1,478 @@
2719+/******************************************************************************
2720+**
2721+** FILE NAME : ifxmips_pcie_phy.c
2722+** PROJECT : IFX UEIP for VRX200
2723+** MODULES : PCIe PHY sub module
2724+**
2725+** DATE : 14 May 2009
2726+** AUTHOR : Lei Chuanhua
2727+** DESCRIPTION : PCIe Root Complex Driver
2728+** COPYRIGHT : Copyright (c) 2009
2729+** Infineon Technologies AG
2730+** Am Campeon 1-12, 85579 Neubiberg, Germany
2731+**
2732+** This program is free software; you can redistribute it and/or modify
2733+** it under the terms of the GNU General Public License as published by
2734+** the Free Software Foundation; either version 2 of the License, or
2735+** (at your option) any later version.
2736+** HISTORY
2737+** $Version $Date $Author $Comment
2738+** 0.0.1 14 May,2009 Lei Chuanhua Initial version
2739+*******************************************************************************/
2740+/*!
2741+ \file ifxmips_pcie_phy.c
2742+ \ingroup IFX_PCIE
2743+ \brief PCIe PHY PLL register programming source file
2744+*/
2745+#include <linux/types.h>
2746+#include <linux/kernel.h>
2747+#include <asm/paccess.h>
2748+#include <linux/delay.h>
2749+
2750+#include "ifxmips_pcie_reg.h"
2751+#include "ifxmips_pcie.h"
2752+
2753+/* PCIe PDI only supports 16 bit operation */
2754+
2755+#define IFX_PCIE_PHY_REG_WRITE16(__addr, __data) \
2756+ ((*(volatile u16 *) (__addr)) = (__data))
2757+
2758+#define IFX_PCIE_PHY_REG_READ16(__addr) \
2759+ (*(volatile u16 *) (__addr))
2760+
2761+#define IFX_PCIE_PHY_REG16(__addr) \
2762+ (*(volatile u16 *) (__addr))
2763+
2764+#define IFX_PCIE_PHY_REG(__reg, __value, __mask) do { \
2765+ u16 read_data; \
2766+ u16 write_data; \
2767+ read_data = IFX_PCIE_PHY_REG_READ16((__reg)); \
2768+ write_data = (read_data & ((u16)~(__mask))) | (((u16)(__value)) & ((u16)(__mask)));\
2769+ IFX_PCIE_PHY_REG_WRITE16((__reg), write_data); \
2770+} while (0)
2771+
2772+#define IFX_PCIE_PLL_TIMEOUT 1000 /* Tunnable */
2773+
2774+//#define IFX_PCI_PHY_REG_DUMP
2775+
2776+#ifdef IFX_PCI_PHY_REG_DUMP
2777+static void
2778+pcie_phy_reg_dump(int pcie_port)
2779+{
2780+ printk("PLL REGFILE\n");
2781+ printk("PCIE_PHY_PLL_CTRL1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_CTRL1(pcie_port)));
2782+ printk("PCIE_PHY_PLL_CTRL2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_CTRL2(pcie_port)));
2783+ printk("PCIE_PHY_PLL_CTRL3 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_CTRL3(pcie_port)));
2784+ printk("PCIE_PHY_PLL_CTRL4 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_CTRL4(pcie_port)));
2785+ printk("PCIE_PHY_PLL_CTRL5 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_CTRL5(pcie_port)));
2786+ printk("PCIE_PHY_PLL_CTRL6 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_CTRL6(pcie_port)));
2787+ printk("PCIE_PHY_PLL_CTRL7 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_CTRL7(pcie_port)));
2788+ printk("PCIE_PHY_PLL_A_CTRL1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_A_CTRL1(pcie_port)));
2789+ printk("PCIE_PHY_PLL_A_CTRL2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_A_CTRL2(pcie_port)));
2790+ printk("PCIE_PHY_PLL_A_CTRL3 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_A_CTRL3(pcie_port)));
2791+ printk("PCIE_PHY_PLL_STATUS 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_STATUS(pcie_port)));
2792+
2793+ printk("TX1 REGFILE\n");
2794+ printk("PCIE_PHY_TX1_CTRL1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_CTRL1(pcie_port)));
2795+ printk("PCIE_PHY_TX1_CTRL2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_CTRL2(pcie_port)));
2796+ printk("PCIE_PHY_TX1_CTRL3 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_CTRL3(pcie_port)));
2797+ printk("PCIE_PHY_TX1_A_CTRL1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_A_CTRL1(pcie_port)));
2798+ printk("PCIE_PHY_TX1_A_CTRL2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_A_CTRL2(pcie_port)));
2799+ printk("PCIE_PHY_TX1_MOD1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_MOD1(pcie_port)));
2800+ printk("PCIE_PHY_TX1_MOD2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_MOD2(pcie_port)));
2801+ printk("PCIE_PHY_TX1_MOD3 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_MOD3(pcie_port)));
2802+
2803+ printk("TX2 REGFILE\n");
2804+ printk("PCIE_PHY_TX2_CTRL1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX2_CTRL1(pcie_port)));
2805+ printk("PCIE_PHY_TX2_CTRL2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX2_CTRL2(pcie_port)));
2806+ printk("PCIE_PHY_TX2_A_CTRL1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX2_A_CTRL1(pcie_port)));
2807+ printk("PCIE_PHY_TX2_A_CTRL2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX2_A_CTRL2(pcie_port)));
2808+ printk("PCIE_PHY_TX2_MOD1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX2_MOD1(pcie_port)));
2809+ printk("PCIE_PHY_TX2_MOD2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX2_MOD2(pcie_port)));
2810+ printk("PCIE_PHY_TX2_MOD3 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX2_MOD3(pcie_port)));
2811+
2812+ printk("RX1 REGFILE\n");
2813+ printk("PCIE_PHY_RX1_CTRL1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_RX1_CTRL1(pcie_port)));
2814+ printk("PCIE_PHY_RX1_CTRL2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_RX1_CTRL2(pcie_port)));
2815+ printk("PCIE_PHY_RX1_CDR 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_RX1_CDR(pcie_port)));
2816+ printk("PCIE_PHY_RX1_EI 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_RX1_EI(pcie_port)));
2817+ printk("PCIE_PHY_RX1_A_CTRL 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_RX1_A_CTRL(pcie_port)));
2818+}
2819+#endif /* IFX_PCI_PHY_REG_DUMP */
2820+
2821+static void
2822+pcie_phy_comm_setup(int pcie_port)
2823+{
2824+ /* PLL Setting */
2825+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL1(pcie_port), 0x120e, 0xFFFF);
2826+
2827+ /* increase the bias reference voltage */
2828+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x39D7, 0xFFFF);
2829+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x0900, 0xFFFF);
2830+
2831+ /* Endcnt */
2832+ IFX_PCIE_PHY_REG(PCIE_PHY_RX1_EI(pcie_port), 0x0004, 0xFFFF);
2833+ IFX_PCIE_PHY_REG(PCIE_PHY_RX1_A_CTRL(pcie_port), 0x6803, 0xFFFF);
2834+
2835+ /* force */
2836+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL1(pcie_port), 0x0008, 0x0008);
2837+
2838+ /* predrv_ser_en */
2839+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_A_CTRL2(pcie_port), 0x0706, 0xFFFF);
2840+
2841+ /* ctrl_lim */
2842+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL3(pcie_port), 0x1FFF, 0xFFFF);
2843+
2844+ /* ctrl */
2845+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_A_CTRL1(pcie_port), 0x0800, 0xFF00);
2846+
2847+ /* predrv_ser_en */
2848+ IFX_PCIE_PHY_REG(PCIE_PHY_TX2_A_CTRL2(pcie_port), 0x4702, 0x7F00);
2849+
2850+ /* RTERM*/
2851+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL2(pcie_port), 0x2e00, 0xFFFF);
2852+
2853+ /* Improved 100MHz clock output */
2854+ IFX_PCIE_PHY_REG(PCIE_PHY_TX2_CTRL2(pcie_port), 0x3096, 0xFFFF);
2855+ IFX_PCIE_PHY_REG(PCIE_PHY_TX2_A_CTRL2(pcie_port), 0x4707, 0xFFFF);
2856+
2857+ /* Reduced CDR BW to avoid glitches */
2858+ IFX_PCIE_PHY_REG(PCIE_PHY_RX1_CDR(pcie_port), 0x0235, 0xFFFF);
2859+}
2860+
2861+#ifdef CONFIG_IFX_PCIE_PHY_36MHZ_MODE
2862+static void
2863+pcie_phy_36mhz_mode_setup(int pcie_port)
2864+{
2865+ IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d enter\n", __func__, pcie_port);
2866+#ifdef IFX_PCI_PHY_REG_DUMP
2867+ IFX_PCIE_PRINT(PCIE_MSG_PHY, "Initial PHY register dump\n");
2868+ pcie_phy_reg_dump(pcie_port);
2869+#endif
2870+
2871+ /* en_ext_mmd_div_ratio */
2872+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0002);
2873+
2874+ /* ext_mmd_div_ratio*/
2875+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0070);
2876+
2877+ /* pll_ensdm */
2878+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0200, 0x0200);
2879+
2880+ /* en_const_sdm */
2881+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0100, 0x0100);
2882+
2883+ /* mmd */
2884+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x2000, 0xe000);
2885+
2886+ /* lf_mode */
2887+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x0000, 0x4000);
2888+
2889+ /* const_sdm */
2890+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL1(pcie_port), 0x38e4, 0xFFFF);
2891+
2892+ /* const sdm */
2893+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x00ee, 0x00FF);
2894+
2895+ /* pllmod */
2896+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL7(pcie_port), 0x0002, 0xFFFF);
2897+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL6(pcie_port), 0x3a04, 0xFFFF);
2898+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL5(pcie_port), 0xfae3, 0xFFFF);
2899+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL4(pcie_port), 0x1b72, 0xFFFF);
2900+
2901+ IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d exit\n", __func__, pcie_port);
2902+}
2903+#endif /* CONFIG_IFX_PCIE_PHY_36MHZ_MODE */
2904+
2905+#ifdef CONFIG_IFX_PCIE_PHY_36MHZ_SSC_MODE
2906+static void
2907+pcie_phy_36mhz_ssc_mode_setup(int pcie_port)
2908+{
2909+ IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d enter\n", __func__, pcie_port);
2910+#ifdef IFX_PCI_PHY_REG_DUMP
2911+ IFX_PCIE_PRINT(PCIE_MSG_PHY, "Initial PHY register dump\n");
2912+ pcie_phy_reg_dump(pcie_port);
2913+#endif
2914+
2915+ /* PLL Setting */
2916+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL1(pcie_port), 0x120e, 0xFFFF);
2917+
2918+ /* Increase the bias reference voltage */
2919+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x39D7, 0xFFFF);
2920+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x0900, 0xFFFF);
2921+
2922+ /* Endcnt */
2923+ IFX_PCIE_PHY_REG(PCIE_PHY_RX1_EI(pcie_port), 0x0004, 0xFFFF);
2924+ IFX_PCIE_PHY_REG(PCIE_PHY_RX1_A_CTRL(pcie_port), 0x6803, 0xFFFF);
2925+
2926+ /* Force */
2927+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL1(pcie_port), 0x0008, 0x0008);
2928+
2929+ /* Predrv_ser_en */
2930+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_A_CTRL2(pcie_port), 0x0706, 0xFFFF);
2931+
2932+ /* ctrl_lim */
2933+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL3(pcie_port), 0x1FFF, 0xFFFF);
2934+
2935+ /* ctrl */
2936+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_A_CTRL1(pcie_port), 0x0800, 0xFF00);
2937+
2938+ /* predrv_ser_en */
2939+ IFX_PCIE_PHY_REG(PCIE_PHY_TX2_A_CTRL2(pcie_port), 0x4702, 0x7F00);
2940+
2941+ /* RTERM*/
2942+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL2(pcie_port), 0x2e00, 0xFFFF);
2943+
2944+ /* en_ext_mmd_div_ratio */
2945+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0002);
2946+
2947+ /* ext_mmd_div_ratio*/
2948+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0070);
2949+
2950+ /* pll_ensdm */
2951+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0400, 0x0400);
2952+
2953+ /* en_const_sdm */
2954+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0200, 0x0200);
2955+
2956+ /* mmd */
2957+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x2000, 0xe000);
2958+
2959+ /* lf_mode */
2960+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x0000, 0x4000);
2961+
2962+ /* const_sdm */
2963+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL1(pcie_port), 0x38e4, 0xFFFF);
2964+
2965+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0000, 0x0100);
2966+ /* const sdm */
2967+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x00ee, 0x00FF);
2968+
2969+ /* pllmod */
2970+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL7(pcie_port), 0x0002, 0xFFFF);
2971+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL6(pcie_port), 0x3a04, 0xFFFF);
2972+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL5(pcie_port), 0xfae3, 0xFFFF);
2973+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL4(pcie_port), 0x1c72, 0xFFFF);
2974+
2975+ /* improved 100MHz clock output */
2976+ IFX_PCIE_PHY_REG(PCIE_PHY_TX2_CTRL2(pcie_port), 0x3096, 0xFFFF);
2977+ IFX_PCIE_PHY_REG(PCIE_PHY_TX2_A_CTRL2(pcie_port), 0x4707, 0xFFFF);
2978+
2979+ /* reduced CDR BW to avoid glitches */
2980+ IFX_PCIE_PHY_REG(PCIE_PHY_RX1_CDR(pcie_port), 0x0235, 0xFFFF);
2981+
2982+ IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d exit\n", __func__, pcie_port);
2983+}
2984+#endif /* CONFIG_IFX_PCIE_PHY_36MHZ_SSC_MODE */
2985+
2986+#ifdef CONFIG_IFX_PCIE_PHY_25MHZ_MODE
2987+static void
2988+pcie_phy_25mhz_mode_setup(int pcie_port)
2989+{
2990+ IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d enter\n", __func__, pcie_port);
2991+#ifdef IFX_PCI_PHY_REG_DUMP
2992+ IFX_PCIE_PRINT(PCIE_MSG_PHY, "Initial PHY register dump\n");
2993+ pcie_phy_reg_dump(pcie_port);
2994+#endif
2995+ /* en_const_sdm */
2996+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0100, 0x0100);
2997+
2998+ /* pll_ensdm */
2999+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0000, 0x0200);
3000+
3001+ /* en_ext_mmd_div_ratio*/
3002+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0002, 0x0002);
3003+
3004+ /* ext_mmd_div_ratio*/
3005+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0040, 0x0070);
3006+
3007+ /* mmd */
3008+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x6000, 0xe000);
3009+
3010+ /* lf_mode */
3011+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x4000, 0x4000);
3012+
3013+ IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d exit\n", __func__, pcie_port);
3014+}
3015+#endif /* CONFIG_IFX_PCIE_PHY_25MHZ_MODE */
3016+
3017+#ifdef CONFIG_IFX_PCIE_PHY_100MHZ_MODE
3018+static void
3019+pcie_phy_100mhz_mode_setup(int pcie_port)
3020+{
3021+ IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d enter\n", __func__, pcie_port);
3022+#ifdef IFX_PCI_PHY_REG_DUMP
3023+ IFX_PCIE_PRINT(PCIE_MSG_PHY, "Initial PHY register dump\n");
3024+ pcie_phy_reg_dump(pcie_port);
3025+#endif
3026+ /* en_ext_mmd_div_ratio */
3027+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0002);
3028+
3029+ /* ext_mmd_div_ratio*/
3030+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0070);
3031+
3032+ /* pll_ensdm */
3033+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0200, 0x0200);
3034+
3035+ /* en_const_sdm */
3036+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0100, 0x0100);
3037+
3038+ /* mmd */
3039+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x2000, 0xe000);
3040+
3041+ /* lf_mode */
3042+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x0000, 0x4000);
3043+
3044+ /* const_sdm */
3045+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL1(pcie_port), 0x38e4, 0xFFFF);
3046+
3047+ /* const sdm */
3048+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x00ee, 0x00FF);
3049+
3050+ /* pllmod */
3051+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL7(pcie_port), 0x0002, 0xFFFF);
3052+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL6(pcie_port), 0x3a04, 0xFFFF);
3053+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL5(pcie_port), 0xfae3, 0xFFFF);
3054+ IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL4(pcie_port), 0x1b72, 0xFFFF);
3055+
3056+ IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d exit\n", __func__, pcie_port);
3057+}
3058+#endif /* CONFIG_IFX_PCIE_PHY_100MHZ_MODE */
3059+
3060+static int
3061+pcie_phy_wait_startup_ready(int pcie_port)
3062+{
3063+ int i;
3064+
3065+ for (i = 0; i < IFX_PCIE_PLL_TIMEOUT; i++) {
3066+ if ((IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_STATUS(pcie_port)) & 0x0040) != 0) {
3067+ break;
3068+ }
3069+ udelay(10);
3070+ }
3071+ if (i >= IFX_PCIE_PLL_TIMEOUT) {
3072+ printk(KERN_ERR "%s PLL Link timeout\n", __func__);
3073+ return -1;
3074+ }
3075+ return 0;
3076+}
3077+
3078+static void
3079+pcie_phy_load_enable(int pcie_port, int slice)
3080+{
3081+ /* Set the load_en of tx/rx slice to '1' */
3082+ switch (slice) {
3083+ case 1:
3084+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL1(pcie_port), 0x0010, 0x0010);
3085+ break;
3086+ case 2:
3087+ IFX_PCIE_PHY_REG(PCIE_PHY_TX2_CTRL1(pcie_port), 0x0010, 0x0010);
3088+ break;
3089+ case 3:
3090+ IFX_PCIE_PHY_REG(PCIE_PHY_RX1_CTRL1(pcie_port), 0x0002, 0x0002);
3091+ break;
3092+ }
3093+}
3094+
3095+static void
3096+pcie_phy_load_disable(int pcie_port, int slice)
3097+{
3098+ /* set the load_en of tx/rx slice to '0' */
3099+ switch (slice) {
3100+ case 1:
3101+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL1(pcie_port), 0x0000, 0x0010);
3102+ break;
3103+ case 2:
3104+ IFX_PCIE_PHY_REG(PCIE_PHY_TX2_CTRL1(pcie_port), 0x0000, 0x0010);
3105+ break;
3106+ case 3:
3107+ IFX_PCIE_PHY_REG(PCIE_PHY_RX1_CTRL1(pcie_port), 0x0000, 0x0002);
3108+ break;
3109+ }
3110+}
3111+
3112+static void
3113+pcie_phy_load_war(int pcie_port)
3114+{
3115+ int slice;
3116+
3117+ for (slice = 1; slice < 4; slice++) {
3118+ pcie_phy_load_enable(pcie_port, slice);
3119+ udelay(1);
3120+ pcie_phy_load_disable(pcie_port, slice);
3121+ }
3122+}
3123+
3124+static void
3125+pcie_phy_tx2_modulation(int pcie_port)
3126+{
3127+ IFX_PCIE_PHY_REG(PCIE_PHY_TX2_MOD1(pcie_port), 0x1FFE, 0xFFFF);
3128+ IFX_PCIE_PHY_REG(PCIE_PHY_TX2_MOD2(pcie_port), 0xFFFE, 0xFFFF);
3129+ IFX_PCIE_PHY_REG(PCIE_PHY_TX2_MOD3(pcie_port), 0x0601, 0xFFFF);
3130+ mdelay(1);
3131+ IFX_PCIE_PHY_REG(PCIE_PHY_TX2_MOD3(pcie_port), 0x0001, 0xFFFF);
3132+}
3133+
3134+static void
3135+pcie_phy_tx1_modulation(int pcie_port)
3136+{
3137+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_MOD1(pcie_port), 0x1FFE, 0xFFFF);
3138+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_MOD2(pcie_port), 0xFFFE, 0xFFFF);
3139+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_MOD3(pcie_port), 0x0601, 0xFFFF);
3140+ mdelay(1);
3141+ IFX_PCIE_PHY_REG(PCIE_PHY_TX1_MOD3(pcie_port), 0x0001, 0xFFFF);
3142+}
3143+
3144+static void
3145+pcie_phy_tx_modulation_war(int pcie_port)
3146+{
3147+ int i;
3148+
3149+#define PCIE_PHY_MODULATION_NUM 5
3150+ for (i = 0; i < PCIE_PHY_MODULATION_NUM; i++) {
3151+ pcie_phy_tx2_modulation(pcie_port);
3152+ pcie_phy_tx1_modulation(pcie_port);
3153+ }
3154+#undef PCIE_PHY_MODULATION_NUM
3155+}
3156+
3157+void
3158+pcie_phy_clock_mode_setup(int pcie_port)
3159+{
3160+ pcie_pdi_big_endian(pcie_port);
3161+
3162+ /* Enable PDI to access PCIe PHY register */
3163+ pcie_pdi_pmu_enable(pcie_port);
3164+
3165+ /* Configure PLL and PHY clock */
3166+ pcie_phy_comm_setup(pcie_port);
3167+
3168+#ifdef CONFIG_IFX_PCIE_PHY_36MHZ_MODE
3169+ pcie_phy_36mhz_mode_setup(pcie_port);
3170+#elif defined(CONFIG_IFX_PCIE_PHY_36MHZ_SSC_MODE)
3171+ pcie_phy_36mhz_ssc_mode_setup(pcie_port);
3172+#elif defined(CONFIG_IFX_PCIE_PHY_25MHZ_MODE)
3173+ pcie_phy_25mhz_mode_setup(pcie_port);
3174+#elif defined (CONFIG_IFX_PCIE_PHY_100MHZ_MODE)
3175+ pcie_phy_100mhz_mode_setup(pcie_port);
3176+#else
3177+ #error "PCIE PHY Clock Mode must be chosen first!!!!"
3178+#endif /* CONFIG_IFX_PCIE_PHY_36MHZ_MODE */
3179+
3180+ /* Enable PCIe PHY and make PLL setting take effect */
3181+ pcie_phy_pmu_enable(pcie_port);
3182+
3183+ /* Check if we are in startup_ready status */
3184+ pcie_phy_wait_startup_ready(pcie_port);
3185+
3186+ pcie_phy_load_war(pcie_port);
3187+
3188+ /* Apply TX modulation workarounds */
3189+ pcie_phy_tx_modulation_war(pcie_port);
3190+
3191+#ifdef IFX_PCI_PHY_REG_DUMP
3192+ IFX_PCIE_PRINT(PCIE_MSG_PHY, "Modified PHY register dump\n");
3193+ pcie_phy_reg_dump(pcie_port);
3194+#endif
3195+}
3196+
3197diff --git a/arch/mips/pci/ifxmips_pcie_pm.c b/arch/mips/pci/ifxmips_pcie_pm.c
3198new file mode 100644
3199index 0000000..a10ecad
3200--- /dev/null
3201+++ b/arch/mips/pci/ifxmips_pcie_pm.c
3202@@ -0,0 +1,176 @@
3203+/******************************************************************************
3204+**
3205+** FILE NAME : ifxmips_pcie_pm.c
3206+** PROJECT : IFX UEIP
3207+** MODULES : PCIE Root Complex Driver
3208+**
3209+** DATE : 21 Dec 2009
3210+** AUTHOR : Lei Chuanhua
3211+** DESCRIPTION : PCIE Root Complex Driver Power Managment
3212+** COPYRIGHT : Copyright (c) 2009
3213+** Lantiq Deutschland GmbH
3214+** Am Campeon 3, 85579 Neubiberg, Germany
3215+**
3216+** This program is free software; you can redistribute it and/or modify
3217+** it under the terms of the GNU General Public License as published by
3218+** the Free Software Foundation; either version 2 of the License, or
3219+** (at your option) any later version.
3220+**
3221+** HISTORY
3222+** $Date $Author $Comment
3223+** 21 Dec,2009 Lei Chuanhua First UEIP release
3224+*******************************************************************************/
3225+/*!
3226+ \defgroup IFX_PCIE_PM Power Management functions
3227+ \ingroup IFX_PCIE
3228+ \brief IFX PCIE Root Complex Driver power management functions
3229+*/
3230+
3231+/*!
3232+ \file ifxmips_pcie_pm.c
3233+ \ingroup IFX_PCIE
3234+ \brief source file for PCIE Root Complex Driver Power Management
3235+*/
3236+
3237+#ifndef EXPORT_SYMTAB
3238+#define EXPORT_SYMTAB
3239+#endif
3240+#ifndef AUTOCONF_INCLUDED
3241+#include <linux/config.h>
3242+#endif /* AUTOCONF_INCLUDED */
3243+#include <linux/version.h>
3244+#include <linux/module.h>
3245+#include <linux/types.h>
3246+#include <linux/kernel.h>
3247+#include <asm/system.h>
3248+
3249+/* Project header */
3250+#include <asm/ifx/ifx_types.h>
3251+#include <asm/ifx/ifx_regs.h>
3252+#include <asm/ifx/common_routines.h>
3253+#include <asm/ifx/ifx_pmcu.h>
3254+#include "ifxmips_pcie_pm.h"
3255+
3256+/**
3257+ * \fn static IFX_PMCU_RETURN_t ifx_pcie_pmcu_state_change(IFX_PMCU_STATE_t pmcuState)
3258+ * \brief the callback function to request pmcu state in the power management hardware-dependent module
3259+ *
3260+ * \param pmcuState This parameter is a PMCU state.
3261+ *
3262+ * \return IFX_PMCU_RETURN_SUCCESS Set Power State successfully
3263+ * \return IFX_PMCU_RETURN_ERROR Failed to set power state.
3264+ * \return IFX_PMCU_RETURN_DENIED Not allowed to operate power state
3265+ * \ingroup IFX_PCIE_PM
3266+ */
3267+static IFX_PMCU_RETURN_t
3268+ifx_pcie_pmcu_state_change(IFX_PMCU_STATE_t pmcuState)
3269+{
3270+ switch(pmcuState)
3271+ {
3272+ case IFX_PMCU_STATE_D0:
3273+ return IFX_PMCU_RETURN_SUCCESS;
3274+ case IFX_PMCU_STATE_D1: // Not Applicable
3275+ return IFX_PMCU_RETURN_DENIED;
3276+ case IFX_PMCU_STATE_D2: // Not Applicable
3277+ return IFX_PMCU_RETURN_DENIED;
3278+ case IFX_PMCU_STATE_D3: // Module clock gating and Power gating
3279+ return IFX_PMCU_RETURN_SUCCESS;
3280+ default:
3281+ return IFX_PMCU_RETURN_DENIED;
3282+ }
3283+}
3284+
3285+/**
3286+ * \fn static IFX_PMCU_RETURN_t ifx_pcie_pmcu_state_get(IFX_PMCU_STATE_t *pmcuState)
3287+ * \brief the callback function to get pmcu state in the power management hardware-dependent module
3288+
3289+ * \param pmcuState Pointer to return power state.
3290+ *
3291+ * \return IFX_PMCU_RETURN_SUCCESS Set Power State successfully
3292+ * \return IFX_PMCU_RETURN_ERROR Failed to set power state.
3293+ * \return IFX_PMCU_RETURN_DENIED Not allowed to operate power state
3294+ * \ingroup IFX_PCIE_PM
3295+ */
3296+static IFX_PMCU_RETURN_t
3297+ifx_pcie_pmcu_state_get(IFX_PMCU_STATE_t *pmcuState)
3298+{
3299+ return IFX_PMCU_RETURN_SUCCESS;
3300+}
3301+
3302+/**
3303+ * \fn IFX_PMCU_RETURN_t ifx_pcie_pmcu_prechange(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
3304+ * \brief Apply all callbacks registered to be executed before a state change for pmcuModule
3305+ *
3306+ * \param pmcuModule Module
3307+ * \param newState New state
3308+ * \param oldState Old state
3309+ * \return IFX_PMCU_RETURN_SUCCESS Set Power State successfully
3310+ * \return IFX_PMCU_RETURN_ERROR Failed to set power state.
3311+ * \ingroup IFX_PCIE_PM
3312+ */
3313+static IFX_PMCU_RETURN_t
3314+ifx_pcie_pmcu_prechange(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
3315+{
3316+ return IFX_PMCU_RETURN_SUCCESS;
3317+}
3318+
3319+/**
3320+ * \fn IFX_PMCU_RETURN_t ifx_pcie_pmcu_postchange(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
3321+ * \brief Apply all callbacks registered to be executed before a state change for pmcuModule
3322+ *
3323+ * \param pmcuModule Module
3324+ * \param newState New state
3325+ * \param oldState Old state
3326+ * \return IFX_PMCU_RETURN_SUCCESS Set Power State successfully
3327+ * \return IFX_PMCU_RETURN_ERROR Failed to set power state.
3328+ * \ingroup IFX_PCIE_PM
3329+ */
3330+static IFX_PMCU_RETURN_t
3331+ifx_pcie_pmcu_postchange(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
3332+{
3333+ return IFX_PMCU_RETURN_SUCCESS;
3334+}
3335+
3336+/**
3337+ * \fn static void ifx_pcie_pmcu_init(void)
3338+ * \brief Register with central PMCU module
3339+ * \return none
3340+ * \ingroup IFX_PCIE_PM
3341+ */
3342+void
3343+ifx_pcie_pmcu_init(void)
3344+{
3345+ IFX_PMCU_REGISTER_t pmcuRegister;
3346+
3347+ /* XXX, hook driver context */
3348+
3349+ /* State function register */
3350+ memset(&pmcuRegister, 0, sizeof(IFX_PMCU_REGISTER_t));
3351+ pmcuRegister.pmcuModule = IFX_PMCU_MODULE_PCIE;
3352+ pmcuRegister.pmcuModuleNr = 0;
3353+ pmcuRegister.ifx_pmcu_state_change = ifx_pcie_pmcu_state_change;
3354+ pmcuRegister.ifx_pmcu_state_get = ifx_pcie_pmcu_state_get;
3355+ pmcuRegister.pre = ifx_pcie_pmcu_prechange;
3356+ pmcuRegister.post= ifx_pcie_pmcu_postchange;
3357+ ifx_pmcu_register(&pmcuRegister);
3358+}
3359+
3360+/**
3361+ * \fn static void ifx_pcie_pmcu_exit(void)
3362+ * \brief Unregister with central PMCU module
3363+ *
3364+ * \return none
3365+ * \ingroup IFX_PCIE_PM
3366+ */
3367+void
3368+ifx_pcie_pmcu_exit(void)
3369+{
3370+ IFX_PMCU_REGISTER_t pmcuUnRegister;
3371+
3372+ /* XXX, hook driver context */
3373+
3374+ pmcuUnRegister.pmcuModule = IFX_PMCU_MODULE_PCIE;
3375+ pmcuUnRegister.pmcuModuleNr = 0;
3376+ ifx_pmcu_unregister(&pmcuUnRegister);
3377+}
3378+
3379diff --git a/arch/mips/pci/ifxmips_pcie_pm.h b/arch/mips/pci/ifxmips_pcie_pm.h
3380new file mode 100644
3381index 0000000..6ece20d
3382--- /dev/null
3383+++ b/arch/mips/pci/ifxmips_pcie_pm.h
3384@@ -0,0 +1,36 @@
3385+/******************************************************************************
3386+**
3387+** FILE NAME : ifxmips_pcie_pm.h
3388+** PROJECT : IFX UEIP
3389+** MODULES : PCIe Root Complex Driver
3390+**
3391+** DATE : 21 Dec 2009
3392+** AUTHOR : Lei Chuanhua
3393+** DESCRIPTION : PCIe Root Complex Driver Power Managment
3394+** COPYRIGHT : Copyright (c) 2009
3395+** Lantiq Deutschland GmbH
3396+** Am Campeon 3, 85579 Neubiberg, Germany
3397+**
3398+** This program is free software; you can redistribute it and/or modify
3399+** it under the terms of the GNU General Public License as published by
3400+** the Free Software Foundation; either version 2 of the License, or
3401+** (at your option) any later version.
3402+**
3403+** HISTORY
3404+** $Date $Author $Comment
3405+** 21 Dec,2009 Lei Chuanhua First UEIP release
3406+*******************************************************************************/
3407+/*!
3408+ \file ifxmips_pcie_pm.h
3409+ \ingroup IFX_PCIE
3410+ \brief header file for PCIe Root Complex Driver Power Management
3411+*/
3412+
3413+#ifndef IFXMIPS_PCIE_PM_H
3414+#define IFXMIPS_PCIE_PM_H
3415+
3416+void ifx_pcie_pmcu_init(void);
3417+void ifx_pcie_pmcu_exit(void);
3418+
3419+#endif /* IFXMIPS_PCIE_PM_H */
3420+
3421diff --git a/arch/mips/pci/ifxmips_pcie_reg.h b/arch/mips/pci/ifxmips_pcie_reg.h
3422new file mode 100644
3423index 0000000..e7e4b6c
3424--- /dev/null
3425+++ b/arch/mips/pci/ifxmips_pcie_reg.h
3426@@ -0,0 +1,1001 @@
3427+/******************************************************************************
3428+**
3429+** FILE NAME : ifxmips_pcie_reg.h
3430+** PROJECT : IFX UEIP for VRX200
3431+** MODULES : PCIe module
3432+**
3433+** DATE : 02 Mar 2009
3434+** AUTHOR : Lei Chuanhua
3435+** DESCRIPTION : PCIe Root Complex Driver
3436+** COPYRIGHT : Copyright (c) 2009
3437+** Infineon Technologies AG
3438+** Am Campeon 1-12, 85579 Neubiberg, Germany
3439+**
3440+** This program is free software; you can redistribute it and/or modify
3441+** it under the terms of the GNU General Public License as published by
3442+** the Free Software Foundation; either version 2 of the License, or
3443+** (at your option) any later version.
3444+** HISTORY
3445+** $Version $Date $Author $Comment
3446+** 0.0.1 17 Mar,2009 Lei Chuanhua Initial version
3447+*******************************************************************************/
3448+#ifndef IFXMIPS_PCIE_REG_H
3449+#define IFXMIPS_PCIE_REG_H
3450+/*!
3451+ \file ifxmips_pcie_reg.h
3452+ \ingroup IFX_PCIE
3453+ \brief header file for PCIe module register definition
3454+*/
3455+/* PCIe Address Mapping Base */
3456+#define PCIE_CFG_PHY_BASE 0x1D000000UL
3457+#define PCIE_CFG_BASE (KSEG1 + PCIE_CFG_PHY_BASE)
3458+#define PCIE_CFG_SIZE (8 * 1024 * 1024)
3459+
3460+#define PCIE_MEM_PHY_BASE 0x1C000000UL
3461+#define PCIE_MEM_BASE (KSEG1 + PCIE_MEM_PHY_BASE)
3462+#define PCIE_MEM_SIZE (16 * 1024 * 1024)
3463+#define PCIE_MEM_PHY_END (PCIE_MEM_PHY_BASE + PCIE_MEM_SIZE - 1)
3464+
3465+#define PCIE_IO_PHY_BASE 0x1D800000UL
3466+#define PCIE_IO_BASE (KSEG1 + PCIE_IO_PHY_BASE)
3467+#define PCIE_IO_SIZE (1 * 1024 * 1024)
3468+#define PCIE_IO_PHY_END (PCIE_IO_PHY_BASE + PCIE_IO_SIZE - 1)
3469+
3470+#define PCIE_RC_CFG_BASE (KSEG1 + 0x1D900000)
3471+#define PCIE_APP_LOGIC_REG (KSEG1 + 0x1E100900)
3472+#define PCIE_MSI_PHY_BASE 0x1F600000UL
3473+
3474+#define PCIE_PDI_PHY_BASE 0x1F106800UL
3475+#define PCIE_PDI_BASE (KSEG1 + PCIE_PDI_PHY_BASE)
3476+#define PCIE_PDI_SIZE 0x400
3477+
3478+#define PCIE1_CFG_PHY_BASE 0x19000000UL
3479+#define PCIE1_CFG_BASE (KSEG1 + PCIE1_CFG_PHY_BASE)
3480+#define PCIE1_CFG_SIZE (8 * 1024 * 1024)
3481+
3482+#define PCIE1_MEM_PHY_BASE 0x18000000UL
3483+#define PCIE1_MEM_BASE (KSEG1 + PCIE1_MEM_PHY_BASE)
3484+#define PCIE1_MEM_SIZE (16 * 1024 * 1024)
3485+#define PCIE1_MEM_PHY_END (PCIE1_MEM_PHY_BASE + PCIE1_MEM_SIZE - 1)
3486+
3487+#define PCIE1_IO_PHY_BASE 0x19800000UL
3488+#define PCIE1_IO_BASE (KSEG1 + PCIE1_IO_PHY_BASE)
3489+#define PCIE1_IO_SIZE (1 * 1024 * 1024)
3490+#define PCIE1_IO_PHY_END (PCIE1_IO_PHY_BASE + PCIE1_IO_SIZE - 1)
3491+
3492+#define PCIE1_RC_CFG_BASE (KSEG1 + 0x19900000)
3493+#define PCIE1_APP_LOGIC_REG (KSEG1 + 0x1E100700)
3494+#define PCIE1_MSI_PHY_BASE 0x1F400000UL
3495+
3496+#define PCIE1_PDI_PHY_BASE 0x1F700400UL
3497+#define PCIE1_PDI_BASE (KSEG1 + PCIE1_PDI_PHY_BASE)
3498+#define PCIE1_PDI_SIZE 0x400
3499+
3500+#define PCIE_CFG_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_CFG_BASE) : (PCIE_CFG_BASE))
3501+#define PCIE_MEM_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_MEM_BASE) : (PCIE_MEM_BASE))
3502+#define PCIE_IO_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_IO_BASE) : (PCIE_IO_BASE))
3503+#define PCIE_MEM_PHY_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_MEM_PHY_BASE) : (PCIE_MEM_PHY_BASE))
3504+#define PCIE_MEM_PHY_PORT_TO_END(X) ((X) > 0 ? (PCIE1_MEM_PHY_END) : (PCIE_MEM_PHY_END))
3505+#define PCIE_IO_PHY_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_IO_PHY_BASE) : (PCIE_IO_PHY_BASE))
3506+#define PCIE_IO_PHY_PORT_TO_END(X) ((X) > 0 ? (PCIE1_IO_PHY_END) : (PCIE_IO_PHY_END))
3507+#define PCIE_APP_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_APP_LOGIC_REG) : (PCIE_APP_LOGIC_REG))
3508+#define PCIE_RC_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_RC_CFG_BASE) : (PCIE_RC_CFG_BASE))
3509+#define PCIE_PHY_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_PDI_BASE) : (PCIE_PDI_BASE))
3510+
3511+/* PCIe Application Logic Register */
3512+/* RC Core Control Register */
3513+#define PCIE_RC_CCR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x10)
3514+/* This should be enabled after initializing configuratin registers
3515+ * Also should check link status retraining bit
3516+ */
3517+#define PCIE_RC_CCR_LTSSM_ENABLE 0x00000001 /* Enable LTSSM to continue link establishment */
3518+
3519+/* RC Core Debug Register */
3520+#define PCIE_RC_DR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x14)
3521+#define PCIE_RC_DR_DLL_UP 0x00000001 /* Data Link Layer Up */
3522+#define PCIE_RC_DR_CURRENT_POWER_STATE 0x0000000E /* Current Power State */
3523+#define PCIE_RC_DR_CURRENT_POWER_STATE_S 1
3524+#define PCIE_RC_DR_CURRENT_LTSSM_STATE 0x000001F0 /* Current LTSSM State */
3525+#define PCIE_RC_DR_CURRENT_LTSSM_STATE_S 4
3526+
3527+#define PCIE_RC_DR_PM_DEV_STATE 0x00000E00 /* Power Management D-State */
3528+#define PCIE_RC_DR_PM_DEV_STATE_S 9
3529+
3530+#define PCIE_RC_DR_PM_ENABLED 0x00001000 /* Power Management State from PMU */
3531+#define PCIE_RC_DR_PME_EVENT_ENABLED 0x00002000 /* Power Management Event Enable State */
3532+#define PCIE_RC_DR_AUX_POWER_ENABLED 0x00004000 /* Auxiliary Power Enable */
3533+
3534+/* Current Power State Definition */
3535+enum {
3536+ PCIE_RC_DR_D0 = 0,
3537+ PCIE_RC_DR_D1, /* Not supported */
3538+ PCIE_RC_DR_D2, /* Not supported */
3539+ PCIE_RC_DR_D3,
3540+ PCIE_RC_DR_UN,
3541+};
3542+
3543+/* PHY Link Status Register */
3544+#define PCIE_PHY_SR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x18)
3545+#define PCIE_PHY_SR_PHY_LINK_UP 0x00000001 /* PHY Link Up/Down Indicator */
3546+
3547+/* Electromechanical Control Register */
3548+#define PCIE_EM_CR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x1C)
3549+#define PCIE_EM_CR_CARD_IS_PRESENT 0x00000001 /* Card Presence Detect State */
3550+#define PCIE_EM_CR_MRL_OPEN 0x00000002 /* MRL Sensor State */
3551+#define PCIE_EM_CR_POWER_FAULT_SET 0x00000004 /* Power Fault Detected */
3552+#define PCIE_EM_CR_MRL_SENSOR_SET 0x00000008 /* MRL Sensor Changed */
3553+#define PCIE_EM_CR_PRESENT_DETECT_SET 0x00000010 /* Card Presense Detect Changed */
3554+#define PCIE_EM_CR_CMD_CPL_INT_SET 0x00000020 /* Command Complete Interrupt */
3555+#define PCIE_EM_CR_SYS_INTERLOCK_SET 0x00000040 /* System Electromechanical IterLock Engaged */
3556+#define PCIE_EM_CR_ATTENTION_BUTTON_SET 0x00000080 /* Attention Button Pressed */
3557+
3558+/* Interrupt Status Register */
3559+#define PCIE_IR_SR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x20)
3560+#define PCIE_IR_SR_PME_CAUSE_MSI 0x00000002 /* MSI caused by PME */
3561+#define PCIE_IR_SR_HP_PME_WAKE_GEN 0x00000004 /* Hotplug PME Wake Generation */
3562+#define PCIE_IR_SR_HP_MSI 0x00000008 /* Hotplug MSI */
3563+#define PCIE_IR_SR_AHB_LU_ERR 0x00000030 /* AHB Bridge Lookup Error Signals */
3564+#define PCIE_IR_SR_AHB_LU_ERR_S 4
3565+#define PCIE_IR_SR_INT_MSG_NUM 0x00003E00 /* Interrupt Message Number */
3566+#define PCIE_IR_SR_INT_MSG_NUM_S 9
3567+#define PCIE_IR_SR_AER_INT_MSG_NUM 0xF8000000 /* Advanced Error Interrupt Message Number */
3568+#define PCIE_IR_SR_AER_INT_MSG_NUM_S 27
3569+
3570+/* Message Control Register */
3571+#define PCIE_MSG_CR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x30)
3572+#define PCIE_MSG_CR_GEN_PME_TURN_OFF_MSG 0x00000001 /* Generate PME Turn Off Message */
3573+#define PCIE_MSG_CR_GEN_UNLOCK_MSG 0x00000002 /* Generate Unlock Message */
3574+
3575+#define PCIE_VDM_DR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x34)
3576+
3577+/* Vendor-Defined Message Requester ID Register */
3578+#define PCIE_VDM_RID(X) (PCIE_APP_PORT_TO_BASE (X) + 0x38)
3579+#define PCIE_VDM_RID_VENROR_MSG_REQ_ID 0x0000FFFF
3580+#define PCIE_VDM_RID_VDMRID_S 0
3581+
3582+/* ASPM Control Register */
3583+#define PCIE_ASPM_CR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x40)
3584+#define PCIE_ASPM_CR_HOT_RST 0x00000001 /* Hot Reset Request to the downstream device */
3585+#define PCIE_ASPM_CR_REQ_EXIT_L1 0x00000002 /* Request to Exit L1 */
3586+#define PCIE_ASPM_CR_REQ_ENTER_L1 0x00000004 /* Request to Enter L1 */
3587+
3588+/* Vendor Message DW0 Register */
3589+#define PCIE_VM_MSG_DW0(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x50)
3590+#define PCIE_VM_MSG_DW0_TYPE 0x0000001F /* Message type */
3591+#define PCIE_VM_MSG_DW0_TYPE_S 0
3592+#define PCIE_VM_MSG_DW0_FORMAT 0x00000060 /* Format */
3593+#define PCIE_VM_MSG_DW0_FORMAT_S 5
3594+#define PCIE_VM_MSG_DW0_TC 0x00007000 /* Traffic Class */
3595+#define PCIE_VM_MSG_DW0_TC_S 12
3596+#define PCIE_VM_MSG_DW0_ATTR 0x000C0000 /* Atrributes */
3597+#define PCIE_VM_MSG_DW0_ATTR_S 18
3598+#define PCIE_VM_MSG_DW0_EP_TLP 0x00100000 /* Poisoned TLP */
3599+#define PCIE_VM_MSG_DW0_TD 0x00200000 /* TLP Digest */
3600+#define PCIE_VM_MSG_DW0_LEN 0xFFC00000 /* Length */
3601+#define PCIE_VM_MSG_DW0_LEN_S 22
3602+
3603+/* Format Definition */
3604+enum {
3605+ PCIE_VM_MSG_FORMAT_00 = 0, /* 3DW Hdr, no data*/
3606+ PCIE_VM_MSG_FORMAT_01, /* 4DW Hdr, no data */
3607+ PCIE_VM_MSG_FORMAT_10, /* 3DW Hdr, with data */
3608+ PCIE_VM_MSG_FORMAT_11, /* 4DW Hdr, with data */
3609+};
3610+
3611+/* Traffic Class Definition */
3612+enum {
3613+ PCIE_VM_MSG_TC0 = 0,
3614+ PCIE_VM_MSG_TC1,
3615+ PCIE_VM_MSG_TC2,
3616+ PCIE_VM_MSG_TC3,
3617+ PCIE_VM_MSG_TC4,
3618+ PCIE_VM_MSG_TC5,
3619+ PCIE_VM_MSG_TC6,
3620+ PCIE_VM_MSG_TC7,
3621+};
3622+
3623+/* Attributes Definition */
3624+enum {
3625+ PCIE_VM_MSG_ATTR_00 = 0, /* RO and No Snoop cleared */
3626+ PCIE_VM_MSG_ATTR_01, /* RO cleared , No Snoop set */
3627+ PCIE_VM_MSG_ATTR_10, /* RO set, No Snoop cleared*/
3628+ PCIE_VM_MSG_ATTR_11, /* RO and No Snoop set */
3629+};
3630+
3631+/* Payload Size Definition */
3632+#define PCIE_VM_MSG_LEN_MIN 0
3633+#define PCIE_VM_MSG_LEN_MAX 1024
3634+
3635+/* Vendor Message DW1 Register */
3636+#define PCIE_VM_MSG_DW1(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x54)
3637+#define PCIE_VM_MSG_DW1_FUNC_NUM 0x00000070 /* Function Number */
3638+#define PCIE_VM_MSG_DW1_FUNC_NUM_S 8
3639+#define PCIE_VM_MSG_DW1_CODE 0x00FF0000 /* Message Code */
3640+#define PCIE_VM_MSG_DW1_CODE_S 16
3641+#define PCIE_VM_MSG_DW1_TAG 0xFF000000 /* Tag */
3642+#define PCIE_VM_MSG_DW1_TAG_S 24
3643+
3644+#define PCIE_VM_MSG_DW2(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x58)
3645+#define PCIE_VM_MSG_DW3(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x5C)
3646+
3647+/* Vendor Message Request Register */
3648+#define PCIE_VM_MSG_REQR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x60)
3649+#define PCIE_VM_MSG_REQR_REQ 0x00000001 /* Vendor Message Request */
3650+
3651+
3652+/* AHB Slave Side Band Control Register */
3653+#define PCIE_AHB_SSB(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x70)
3654+#define PCIE_AHB_SSB_REQ_BCM 0x00000001 /* Slave Reques BCM filed */
3655+#define PCIE_AHB_SSB_REQ_EP 0x00000002 /* Slave Reques EP filed */
3656+#define PCIE_AHB_SSB_REQ_TD 0x00000004 /* Slave Reques TD filed */
3657+#define PCIE_AHB_SSB_REQ_ATTR 0x00000018 /* Slave Reques Attribute number */
3658+#define PCIE_AHB_SSB_REQ_ATTR_S 3
3659+#define PCIE_AHB_SSB_REQ_TC 0x000000E0 /* Slave Request TC Field */
3660+#define PCIE_AHB_SSB_REQ_TC_S 5
3661+
3662+/* AHB Master SideBand Ctrl Register */
3663+#define PCIE_AHB_MSB(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x74)
3664+#define PCIE_AHB_MSB_RESP_ATTR 0x00000003 /* Master Response Attribute number */
3665+#define PCIE_AHB_MSB_RESP_ATTR_S 0
3666+#define PCIE_AHB_MSB_RESP_BAD_EOT 0x00000004 /* Master Response Badeot filed */
3667+#define PCIE_AHB_MSB_RESP_BCM 0x00000008 /* Master Response BCM filed */
3668+#define PCIE_AHB_MSB_RESP_EP 0x00000010 /* Master Response EP filed */
3669+#define PCIE_AHB_MSB_RESP_TD 0x00000020 /* Master Response TD filed */
3670+#define PCIE_AHB_MSB_RESP_FUN_NUM 0x000003C0 /* Master Response Function number */
3671+#define PCIE_AHB_MSB_RESP_FUN_NUM_S 6
3672+
3673+/* AHB Control Register, fixed bus enumeration exception */
3674+#define PCIE_AHB_CTRL(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x78)
3675+#define PCIE_AHB_CTRL_BUS_ERROR_SUPPRESS 0x00000001
3676+
3677+/* Interrupt Enalbe Register */
3678+#define PCIE_IRNEN(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0xF4)
3679+#define PCIE_IRNCR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0xF8)
3680+#define PCIE_IRNICR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0xFC)
3681+
3682+/* PCIe interrupt enable/control/capture register definition */
3683+#define PCIE_IRN_AER_REPORT 0x00000001 /* AER Interrupt */
3684+#define PCIE_IRN_AER_MSIX 0x00000002 /* Advanced Error MSI-X Interrupt */
3685+#define PCIE_IRN_PME 0x00000004 /* PME Interrupt */
3686+#define PCIE_IRN_HOTPLUG 0x00000008 /* Hotplug Interrupt */
3687+#define PCIE_IRN_RX_VDM_MSG 0x00000010 /* Vendor-Defined Message Interrupt */
3688+#define PCIE_IRN_RX_CORRECTABLE_ERR_MSG 0x00000020 /* Correctable Error Message Interrupt */
3689+#define PCIE_IRN_RX_NON_FATAL_ERR_MSG 0x00000040 /* Non-fatal Error Message */
3690+#define PCIE_IRN_RX_FATAL_ERR_MSG 0x00000080 /* Fatal Error Message */
3691+#define PCIE_IRN_RX_PME_MSG 0x00000100 /* PME Message Interrupt */
3692+#define PCIE_IRN_RX_PME_TURNOFF_ACK 0x00000200 /* PME Turnoff Ack Message Interrupt */
3693+#define PCIE_IRN_AHB_BR_FATAL_ERR 0x00000400 /* AHB Fatal Error Interrupt */
3694+#define PCIE_IRN_LINK_AUTO_BW_STATUS 0x00000800 /* Link Auto Bandwidth Status Interrupt */
3695+#define PCIE_IRN_BW_MGT 0x00001000 /* Bandwidth Managment Interrupt */
3696+#define PCIE_IRN_INTA 0x00002000 /* INTA */
3697+#define PCIE_IRN_INTB 0x00004000 /* INTB */
3698+#define PCIE_IRN_INTC 0x00008000 /* INTC */
3699+#define PCIE_IRN_INTD 0x00010000 /* INTD */
3700+#define PCIE_IRN_WAKEUP 0x00020000 /* Wake up Interrupt */
3701+
3702+#define PCIE_RC_CORE_COMBINED_INT (PCIE_IRN_AER_REPORT | PCIE_IRN_AER_MSIX | PCIE_IRN_PME | \
3703+ PCIE_IRN_HOTPLUG | PCIE_IRN_RX_VDM_MSG | PCIE_IRN_RX_CORRECTABLE_ERR_MSG |\
3704+ PCIE_IRN_RX_NON_FATAL_ERR_MSG | PCIE_IRN_RX_FATAL_ERR_MSG | \
3705+ PCIE_IRN_RX_PME_MSG | PCIE_IRN_RX_PME_TURNOFF_ACK | PCIE_IRN_AHB_BR_FATAL_ERR | \
3706+ PCIE_IRN_LINK_AUTO_BW_STATUS | PCIE_IRN_BW_MGT)
3707+/* PCIe RC Configuration Register */
3708+#define PCIE_VDID(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x00)
3709+
3710+/* Bit definition from pci_reg.h */
3711+#define PCIE_PCICMDSTS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x04)
3712+#define PCIE_CCRID(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x08)
3713+#define PCIE_CLSLTHTBR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x0C) /* EP only */
3714+/* BAR0, BAR1,Only necessary if the bridges implements a device-specific register set or memory buffer */
3715+#define PCIE_BAR0(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x10) /* Not used*/
3716+#define PCIE_BAR1(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x14) /* Not used */
3717+
3718+#define PCIE_BNR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x18) /* Mandatory */
3719+/* Bus Number Register bits */
3720+#define PCIE_BNR_PRIMARY_BUS_NUM 0x000000FF
3721+#define PCIE_BNR_PRIMARY_BUS_NUM_S 0
3722+#define PCIE_PNR_SECONDARY_BUS_NUM 0x0000FF00
3723+#define PCIE_PNR_SECONDARY_BUS_NUM_S 8
3724+#define PCIE_PNR_SUB_BUS_NUM 0x00FF0000
3725+#define PCIE_PNR_SUB_BUS_NUM_S 16
3726+
3727+/* IO Base/Limit Register bits */
3728+#define PCIE_IOBLSECS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x1C) /* RC only */
3729+#define PCIE_IOBLSECS_32BIT_IO_ADDR 0x00000001
3730+#define PCIE_IOBLSECS_IO_BASE_ADDR 0x000000F0
3731+#define PCIE_IOBLSECS_IO_BASE_ADDR_S 4
3732+#define PCIE_IOBLSECS_32BIT_IOLIMT 0x00000100
3733+#define PCIE_IOBLSECS_IO_LIMIT_ADDR 0x0000F000
3734+#define PCIE_IOBLSECS_IO_LIMIT_ADDR_S 12
3735+
3736+/* Non-prefetchable Memory Base/Limit Register bit */
3737+#define PCIE_MBML(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x20) /* RC only */
3738+#define PCIE_MBML_MEM_BASE_ADDR 0x0000FFF0
3739+#define PCIE_MBML_MEM_BASE_ADDR_S 4
3740+#define PCIE_MBML_MEM_LIMIT_ADDR 0xFFF00000
3741+#define PCIE_MBML_MEM_LIMIT_ADDR_S 20
3742+
3743+/* Prefetchable Memory Base/Limit Register bit */
3744+#define PCIE_PMBL(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x24) /* RC only */
3745+#define PCIE_PMBL_64BIT_ADDR 0x00000001
3746+#define PCIE_PMBL_UPPER_12BIT 0x0000FFF0
3747+#define PCIE_PMBL_UPPER_12BIT_S 4
3748+#define PCIE_PMBL_E64MA 0x00010000
3749+#define PCIE_PMBL_END_ADDR 0xFFF00000
3750+#define PCIE_PMBL_END_ADDR_S 20
3751+#define PCIE_PMBU32(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x28) /* RC only */
3752+#define PCIE_PMLU32(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x2C) /* RC only */
3753+
3754+/* I/O Base/Limit Upper 16 bits register */
3755+#define PCIE_IO_BANDL(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x30) /* RC only */
3756+#define PCIE_IO_BANDL_UPPER_16BIT_IO_BASE 0x0000FFFF
3757+#define PCIE_IO_BANDL_UPPER_16BIT_IO_BASE_S 0
3758+#define PCIE_IO_BANDL_UPPER_16BIT_IO_LIMIT 0xFFFF0000
3759+#define PCIE_IO_BANDL_UPPER_16BIT_IO_LIMIT_S 16
3760+
3761+#define PCIE_CPR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x34)
3762+#define PCIE_EBBAR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x38)
3763+
3764+/* Interrupt and Secondary Bridge Control Register */
3765+#define PCIE_INTRBCTRL(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x3C)
3766+
3767+#define PCIE_INTRBCTRL_INT_LINE 0x000000FF
3768+#define PCIE_INTRBCTRL_INT_LINE_S 0
3769+#define PCIE_INTRBCTRL_INT_PIN 0x0000FF00
3770+#define PCIE_INTRBCTRL_INT_PIN_S 8
3771+#define PCIE_INTRBCTRL_PARITY_ERR_RESP_ENABLE 0x00010000 /* #PERR */
3772+#define PCIE_INTRBCTRL_SERR_ENABLE 0x00020000 /* #SERR */
3773+#define PCIE_INTRBCTRL_ISA_ENABLE 0x00040000 /* ISA enable, IO 64KB only */
3774+#define PCIE_INTRBCTRL_VGA_ENABLE 0x00080000 /* VGA enable */
3775+#define PCIE_INTRBCTRL_VGA_16BIT_DECODE 0x00100000 /* VGA 16bit decode */
3776+#define PCIE_INTRBCTRL_RST_SECONDARY_BUS 0x00400000 /* Secondary bus rest, hot rest, 1ms */
3777+/* Others are read only */
3778+enum {
3779+ PCIE_INTRBCTRL_INT_NON = 0,
3780+ PCIE_INTRBCTRL_INTA,
3781+ PCIE_INTRBCTRL_INTB,
3782+ PCIE_INTRBCTRL_INTC,
3783+ PCIE_INTRBCTRL_INTD,
3784+};
3785+
3786+#define PCIE_PM_CAPR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x40)
3787+
3788+/* Power Management Control and Status Register */
3789+#define PCIE_PM_CSR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x44)
3790+
3791+#define PCIE_PM_CSR_POWER_STATE 0x00000003 /* Power State */
3792+#define PCIE_PM_CSR_POWER_STATE_S 0
3793+#define PCIE_PM_CSR_SW_RST 0x00000008 /* Soft Reset Enabled */
3794+#define PCIE_PM_CSR_PME_ENABLE 0x00000100 /* PME Enable */
3795+#define PCIE_PM_CSR_PME_STATUS 0x00008000 /* PME status */
3796+
3797+/* MSI Capability Register for EP */
3798+#define PCIE_MCAPR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x50)
3799+
3800+#define PCIE_MCAPR_MSI_CAP_ID 0x000000FF /* MSI Capability ID */
3801+#define PCIE_MCAPR_MSI_CAP_ID_S 0
3802+#define PCIE_MCAPR_MSI_NEXT_CAP_PTR 0x0000FF00 /* Next Capability Pointer */
3803+#define PCIE_MCAPR_MSI_NEXT_CAP_PTR_S 8
3804+#define PCIE_MCAPR_MSI_ENABLE 0x00010000 /* MSI Enable */
3805+#define PCIE_MCAPR_MULTI_MSG_CAP 0x000E0000 /* Multiple Message Capable */
3806+#define PCIE_MCAPR_MULTI_MSG_CAP_S 17
3807+#define PCIE_MCAPR_MULTI_MSG_ENABLE 0x00700000 /* Multiple Message Enable */
3808+#define PCIE_MCAPR_MULTI_MSG_ENABLE_S 20
3809+#define PCIE_MCAPR_ADDR64_CAP 0X00800000 /* 64-bit Address Capable */
3810+
3811+/* MSI Message Address Register */
3812+#define PCIE_MA(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x54)
3813+
3814+#define PCIE_MA_ADDR_MASK 0xFFFFFFFC /* Message Address */
3815+
3816+/* MSI Message Upper Address Register */
3817+#define PCIE_MUA(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x58)
3818+
3819+/* MSI Message Data Register */
3820+#define PCIE_MD(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x5C)
3821+
3822+#define PCIE_MD_DATA 0x0000FFFF /* Message Data */
3823+#define PCIE_MD_DATA_S 0
3824+
3825+/* PCI Express Capability Register */
3826+#define PCIE_XCAP(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x70)
3827+
3828+#define PCIE_XCAP_ID 0x000000FF /* PCI Express Capability ID */
3829+#define PCIE_XCAP_ID_S 0
3830+#define PCIE_XCAP_NEXT_CAP 0x0000FF00 /* Next Capability Pointer */
3831+#define PCIE_XCAP_NEXT_CAP_S 8
3832+#define PCIE_XCAP_VER 0x000F0000 /* PCI Express Capability Version */
3833+#define PCIE_XCAP_VER_S 16
3834+#define PCIE_XCAP_DEV_PORT_TYPE 0x00F00000 /* Device Port Type */
3835+#define PCIE_XCAP_DEV_PORT_TYPE_S 20
3836+#define PCIE_XCAP_SLOT_IMPLEMENTED 0x01000000 /* Slot Implemented */
3837+#define PCIE_XCAP_MSG_INT_NUM 0x3E000000 /* Interrupt Message Number */
3838+#define PCIE_XCAP_MSG_INT_NUM_S 25
3839+
3840+/* Device Capability Register */
3841+#define PCIE_DCAP(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x74)
3842+
3843+#define PCIE_DCAP_MAX_PAYLOAD_SIZE 0x00000007 /* Max Payload size */
3844+#define PCIE_DCAP_MAX_PAYLOAD_SIZE_S 0
3845+#define PCIE_DCAP_PHANTOM_FUNC 0x00000018 /* Phanton Function, not supported */
3846+#define PCIE_DCAP_PHANTOM_FUNC_S 3
3847+#define PCIE_DCAP_EXT_TAG 0x00000020 /* Extended Tag Field */
3848+#define PCIE_DCAP_EP_L0S_LATENCY 0x000001C0 /* EP L0s latency only */
3849+#define PCIE_DCAP_EP_L0S_LATENCY_S 6
3850+#define PCIE_DCAP_EP_L1_LATENCY 0x00000E00 /* EP L1 latency only */
3851+#define PCIE_DCAP_EP_L1_LATENCY_S 9
3852+#define PCIE_DCAP_ROLE_BASE_ERR_REPORT 0x00008000 /* Role Based ERR */
3853+
3854+/* Maximum payload size supported */
3855+enum {
3856+ PCIE_MAX_PAYLOAD_128 = 0,
3857+ PCIE_MAX_PAYLOAD_256,
3858+ PCIE_MAX_PAYLOAD_512,
3859+ PCIE_MAX_PAYLOAD_1024,
3860+ PCIE_MAX_PAYLOAD_2048,
3861+ PCIE_MAX_PAYLOAD_4096,
3862+};
3863+
3864+/* Device Control and Status Register */
3865+#define PCIE_DCTLSTS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x78)
3866+
3867+#define PCIE_DCTLSTS_CORRECTABLE_ERR_EN 0x00000001 /* COR-ERR */
3868+#define PCIE_DCTLSTS_NONFATAL_ERR_EN 0x00000002 /* Non-fatal ERR */
3869+#define PCIE_DCTLSTS_FATAL_ERR_EN 0x00000004 /* Fatal ERR */
3870+#define PCIE_DCTLSYS_UR_REQ_EN 0x00000008 /* UR ERR */
3871+#define PCIE_DCTLSTS_RELAXED_ORDERING_EN 0x00000010 /* Enable relaxing ordering */
3872+#define PCIE_DCTLSTS_MAX_PAYLOAD_SIZE 0x000000E0 /* Max payload mask */
3873+#define PCIE_DCTLSTS_MAX_PAYLOAD_SIZE_S 5
3874+#define PCIE_DCTLSTS_EXT_TAG_EN 0x00000100 /* Extended tag field */
3875+#define PCIE_DCTLSTS_PHANTOM_FUNC_EN 0x00000200 /* Phantom Function Enable */
3876+#define PCIE_DCTLSTS_AUX_PM_EN 0x00000400 /* AUX Power PM Enable */
3877+#define PCIE_DCTLSTS_NO_SNOOP_EN 0x00000800 /* Enable no snoop, except root port*/
3878+#define PCIE_DCTLSTS_MAX_READ_SIZE 0x00007000 /* Max Read Request size*/
3879+#define PCIE_DCTLSTS_MAX_READ_SIZE_S 12
3880+#define PCIE_DCTLSTS_CORRECTABLE_ERR 0x00010000 /* COR-ERR Detected */
3881+#define PCIE_DCTLSTS_NONFATAL_ERR 0x00020000 /* Non-Fatal ERR Detected */
3882+#define PCIE_DCTLSTS_FATAL_ER 0x00040000 /* Fatal ERR Detected */
3883+#define PCIE_DCTLSTS_UNSUPPORTED_REQ 0x00080000 /* UR Detected */
3884+#define PCIE_DCTLSTS_AUX_POWER 0x00100000 /* Aux Power Detected */
3885+#define PCIE_DCTLSTS_TRANSACT_PENDING 0x00200000 /* Transaction pending */
3886+
3887+#define PCIE_DCTLSTS_ERR_EN (PCIE_DCTLSTS_CORRECTABLE_ERR_EN | \
3888+ PCIE_DCTLSTS_NONFATAL_ERR_EN | PCIE_DCTLSTS_FATAL_ERR_EN | \
3889+ PCIE_DCTLSYS_UR_REQ_EN)
3890+
3891+/* Link Capability Register */
3892+#define PCIE_LCAP(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x7C)
3893+#define PCIE_LCAP_MAX_LINK_SPEED 0x0000000F /* Max link speed, 0x1 by default */
3894+#define PCIE_LCAP_MAX_LINK_SPEED_S 0
3895+#define PCIE_LCAP_MAX_LENGTH_WIDTH 0x000003F0 /* Maxium Length Width */
3896+#define PCIE_LCAP_MAX_LENGTH_WIDTH_S 4
3897+#define PCIE_LCAP_ASPM_LEVEL 0x00000C00 /* Active State Link PM Support */
3898+#define PCIE_LCAP_ASPM_LEVEL_S 10
3899+#define PCIE_LCAP_L0S_EIXT_LATENCY 0x00007000 /* L0s Exit Latency */
3900+#define PCIE_LCAP_L0S_EIXT_LATENCY_S 12
3901+#define PCIE_LCAP_L1_EXIT_LATENCY 0x00038000 /* L1 Exit Latency */
3902+#define PCIE_LCAP_L1_EXIT_LATENCY_S 15
3903+#define PCIE_LCAP_CLK_PM 0x00040000 /* Clock Power Management */
3904+#define PCIE_LCAP_SDER 0x00080000 /* Surprise Down Error Reporting */
3905+#define PCIE_LCAP_DLL_ACTIVE_REPROT 0x00100000 /* Data Link Layer Active Reporting Capable */
3906+#define PCIE_LCAP_PORT_NUM 0xFF0000000 /* Port number */
3907+#define PCIE_LCAP_PORT_NUM_S 24
3908+
3909+/* Maximum Length width definition */
3910+#define PCIE_MAX_LENGTH_WIDTH_RES 0x00
3911+#define PCIE_MAX_LENGTH_WIDTH_X1 0x01 /* Default */
3912+#define PCIE_MAX_LENGTH_WIDTH_X2 0x02
3913+#define PCIE_MAX_LENGTH_WIDTH_X4 0x04
3914+#define PCIE_MAX_LENGTH_WIDTH_X8 0x08
3915+#define PCIE_MAX_LENGTH_WIDTH_X12 0x0C
3916+#define PCIE_MAX_LENGTH_WIDTH_X16 0x10
3917+#define PCIE_MAX_LENGTH_WIDTH_X32 0x20
3918+
3919+/* Active State Link PM definition */
3920+enum {
3921+ PCIE_ASPM_RES0 = 0,
3922+ PCIE_ASPM_L0S_ENTRY_SUPPORT, /* L0s */
3923+ PCIE_ASPM_RES1,
3924+ PCIE_ASPM_L0S_L1_ENTRY_SUPPORT, /* L0s and L1, default */
3925+};
3926+
3927+/* L0s Exit Latency definition */
3928+enum {
3929+ PCIE_L0S_EIXT_LATENCY_L64NS = 0, /* < 64 ns */
3930+ PCIE_L0S_EIXT_LATENCY_B64A128, /* > 64 ns < 128 ns */
3931+ PCIE_L0S_EIXT_LATENCY_B128A256, /* > 128 ns < 256 ns */
3932+ PCIE_L0S_EIXT_LATENCY_B256A512, /* > 256 ns < 512 ns */
3933+ PCIE_L0S_EIXT_LATENCY_B512TO1U, /* > 512 ns < 1 us */
3934+ PCIE_L0S_EIXT_LATENCY_B1A2U, /* > 1 us < 2 us */
3935+ PCIE_L0S_EIXT_LATENCY_B2A4U, /* > 2 us < 4 us */
3936+ PCIE_L0S_EIXT_LATENCY_M4US, /* > 4 us */
3937+};
3938+
3939+/* L1 Exit Latency definition */
3940+enum {
3941+ PCIE_L1_EXIT_LATENCY_L1US = 0, /* < 1 us */
3942+ PCIE_L1_EXIT_LATENCY_B1A2, /* > 1 us < 2 us */
3943+ PCIE_L1_EXIT_LATENCY_B2A4, /* > 2 us < 4 us */
3944+ PCIE_L1_EXIT_LATENCY_B4A8, /* > 4 us < 8 us */
3945+ PCIE_L1_EXIT_LATENCY_B8A16, /* > 8 us < 16 us */
3946+ PCIE_L1_EXIT_LATENCY_B16A32, /* > 16 us < 32 us */
3947+ PCIE_L1_EXIT_LATENCY_B32A64, /* > 32 us < 64 us */
3948+ PCIE_L1_EXIT_LATENCY_M64US, /* > 64 us */
3949+};
3950+
3951+/* Link Control and Status Register */
3952+#define PCIE_LCTLSTS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x80)
3953+#define PCIE_LCTLSTS_ASPM_ENABLE 0x00000003 /* Active State Link PM Control */
3954+#define PCIE_LCTLSTS_ASPM_ENABLE_S 0
3955+#define PCIE_LCTLSTS_RCB128 0x00000008 /* Read Completion Boundary 128*/
3956+#define PCIE_LCTLSTS_LINK_DISABLE 0x00000010 /* Link Disable */
3957+#define PCIE_LCTLSTS_RETRIAN_LINK 0x00000020 /* Retrain Link */
3958+#define PCIE_LCTLSTS_COM_CLK_CFG 0x00000040 /* Common Clock Configuration */
3959+#define PCIE_LCTLSTS_EXT_SYNC 0x00000080 /* Extended Synch */
3960+#define PCIE_LCTLSTS_CLK_PM_EN 0x00000100 /* Enable Clock Powerm Management */
3961+#define PCIE_LCTLSTS_LINK_SPEED 0x000F0000 /* Link Speed */
3962+#define PCIE_LCTLSTS_LINK_SPEED_S 16
3963+#define PCIE_LCTLSTS_NEGOTIATED_LINK_WIDTH 0x03F00000 /* Negotiated Link Width */
3964+#define PCIE_LCTLSTS_NEGOTIATED_LINK_WIDTH_S 20
3965+#define PCIE_LCTLSTS_RETRAIN_PENDING 0x08000000 /* Link training is ongoing */
3966+#define PCIE_LCTLSTS_SLOT_CLK_CFG 0x10000000 /* Slot Clock Configuration */
3967+#define PCIE_LCTLSTS_DLL_ACTIVE 0x20000000 /* Data Link Layer Active */
3968+
3969+/* Slot Capabilities Register */
3970+#define PCIE_SLCAP(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x84)
3971+
3972+/* Slot Capabilities */
3973+#define PCIE_SLCTLSTS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x88)
3974+
3975+/* Root Control and Capability Register */
3976+#define PCIE_RCTLCAP(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x8C)
3977+#define PCIE_RCTLCAP_SERR_ON_CORRECTABLE_ERR 0x00000001 /* #SERR on COR-ERR */
3978+#define PCIE_RCTLCAP_SERR_ON_NONFATAL_ERR 0x00000002 /* #SERR on Non-Fatal ERR */
3979+#define PCIE_RCTLCAP_SERR_ON_FATAL_ERR 0x00000004 /* #SERR on Fatal ERR */
3980+#define PCIE_RCTLCAP_PME_INT_EN 0x00000008 /* PME Interrupt Enable */
3981+#define PCIE_RCTLCAP_SERR_ENABLE (PCIE_RCTLCAP_SERR_ON_CORRECTABLE_ERR | \
3982+ PCIE_RCTLCAP_SERR_ON_NONFATAL_ERR | PCIE_RCTLCAP_SERR_ON_FATAL_ERR)
3983+/* Root Status Register */
3984+#define PCIE_RSTS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x90)
3985+#define PCIE_RSTS_PME_REQ_ID 0x0000FFFF /* PME Request ID */
3986+#define PCIE_RSTS_PME_REQ_ID_S 0
3987+#define PCIE_RSTS_PME_STATUS 0x00010000 /* PME Status */
3988+#define PCIE_RSTS_PME_PENDING 0x00020000 /* PME Pending */
3989+
3990+/* PCI Express Enhanced Capability Header */
3991+#define PCIE_ENHANCED_CAP(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x100)
3992+#define PCIE_ENHANCED_CAP_ID 0x0000FFFF /* PCI Express Extended Capability ID */
3993+#define PCIE_ENHANCED_CAP_ID_S 0
3994+#define PCIE_ENHANCED_CAP_VER 0x000F0000 /* Capability Version */
3995+#define PCIE_ENHANCED_CAP_VER_S 16
3996+#define PCIE_ENHANCED_CAP_NEXT_OFFSET 0xFFF00000 /* Next Capability Offset */
3997+#define PCIE_ENHANCED_CAP_NEXT_OFFSET_S 20
3998+
3999+/* Uncorrectable Error Status Register */
4000+#define PCIE_UES_R(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x104)
4001+#define PCIE_DATA_LINK_PROTOCOL_ERR 0x00000010 /* Data Link Protocol Error Status */
4002+#define PCIE_SURPRISE_DOWN_ERROR 0x00000020 /* Surprise Down Error Status */
4003+#define PCIE_POISONED_TLP 0x00001000 /* Poisoned TLP Status */
4004+#define PCIE_FC_PROTOCOL_ERR 0x00002000 /* Flow Control Protocol Error Status */
4005+#define PCIE_COMPLETION_TIMEOUT 0x00004000 /* Completion Timeout Status */
4006+#define PCIE_COMPLETOR_ABORT 0x00008000 /* Completer Abort Error */
4007+#define PCIE_UNEXPECTED_COMPLETION 0x00010000 /* Unexpected Completion Status */
4008+#define PCIE_RECEIVER_OVERFLOW 0x00020000 /* Receive Overflow Status */
4009+#define PCIE_MALFORNED_TLP 0x00040000 /* Malformed TLP Stauts */
4010+#define PCIE_ECRC_ERR 0x00080000 /* ECRC Error Stauts */
4011+#define PCIE_UR_REQ 0x00100000 /* Unsupported Request Error Status */
4012+#define PCIE_ALL_UNCORRECTABLE_ERR (PCIE_DATA_LINK_PROTOCOL_ERR | PCIE_SURPRISE_DOWN_ERROR | \
4013+ PCIE_POISONED_TLP | PCIE_FC_PROTOCOL_ERR | PCIE_COMPLETION_TIMEOUT | \
4014+ PCIE_COMPLETOR_ABORT | PCIE_UNEXPECTED_COMPLETION | PCIE_RECEIVER_OVERFLOW |\
4015+ PCIE_MALFORNED_TLP | PCIE_ECRC_ERR | PCIE_UR_REQ)
4016+
4017+/* Uncorrectable Error Mask Register, Mask means no report */
4018+#define PCIE_UEMR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x108)
4019+
4020+/* Uncorrectable Error Severity Register */
4021+#define PCIE_UESR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x10C)
4022+
4023+/* Correctable Error Status Register */
4024+#define PCIE_CESR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x110)
4025+#define PCIE_RX_ERR 0x00000001 /* Receive Error Status */
4026+#define PCIE_BAD_TLP 0x00000040 /* Bad TLP Status */
4027+#define PCIE_BAD_DLLP 0x00000080 /* Bad DLLP Status */
4028+#define PCIE_REPLAY_NUM_ROLLOVER 0x00000100 /* Replay Number Rollover Status */
4029+#define PCIE_REPLAY_TIMER_TIMEOUT_ERR 0x00001000 /* Reply Timer Timeout Status */
4030+#define PCIE_ADVISORY_NONFTAL_ERR 0x00002000 /* Advisory Non-Fatal Error Status */
4031+#define PCIE_CORRECTABLE_ERR (PCIE_RX_ERR | PCIE_BAD_TLP | PCIE_BAD_DLLP | PCIE_REPLAY_NUM_ROLLOVER |\
4032+ PCIE_REPLAY_TIMER_TIMEOUT_ERR | PCIE_ADVISORY_NONFTAL_ERR)
4033+
4034+/* Correctable Error Mask Register */
4035+#define PCIE_CEMR(X) (volatile u32*)(PCIE_RC_CFG_BASE + 0x114)
4036+
4037+/* Advanced Error Capabilities and Control Register */
4038+#define PCIE_AECCR(X) (volatile u32*)(PCIE_RC_CFG_BASE + 0x118)
4039+#define PCIE_AECCR_FIRST_ERR_PTR 0x0000001F /* First Error Pointer */
4040+#define PCIE_AECCR_FIRST_ERR_PTR_S 0
4041+#define PCIE_AECCR_ECRC_GEN_CAP 0x00000020 /* ECRC Generation Capable */
4042+#define PCIE_AECCR_ECRC_GEN_EN 0x00000040 /* ECRC Generation Enable */
4043+#define PCIE_AECCR_ECRC_CHECK_CAP 0x00000080 /* ECRC Check Capable */
4044+#define PCIE_AECCR_ECRC_CHECK_EN 0x00000100 /* ECRC Check Enable */
4045+
4046+/* Header Log Register 1 */
4047+#define PCIE_HLR1(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x11C)
4048+
4049+/* Header Log Register 2 */
4050+#define PCIE_HLR2(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x120)
4051+
4052+/* Header Log Register 3 */
4053+#define PCIE_HLR3(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x124)
4054+
4055+/* Header Log Register 4 */
4056+#define PCIE_HLR4(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x128)
4057+
4058+/* Root Error Command Register */
4059+#define PCIE_RECR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x12C)
4060+#define PCIE_RECR_CORRECTABLE_ERR_REPORT_EN 0x00000001 /* COR-ERR */
4061+#define PCIE_RECR_NONFATAL_ERR_REPORT_EN 0x00000002 /* Non-Fatal ERR */
4062+#define PCIE_RECR_FATAL_ERR_REPORT_EN 0x00000004 /* Fatal ERR */
4063+#define PCIE_RECR_ERR_REPORT_EN (PCIE_RECR_CORRECTABLE_ERR_REPORT_EN | \
4064+ PCIE_RECR_NONFATAL_ERR_REPORT_EN | PCIE_RECR_FATAL_ERR_REPORT_EN)
4065+
4066+/* Root Error Status Register */
4067+#define PCIE_RESR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x130)
4068+#define PCIE_RESR_CORRECTABLE_ERR 0x00000001 /* COR-ERR Receveid */
4069+#define PCIE_RESR_MULTI_CORRECTABLE_ERR 0x00000002 /* Multiple COR-ERR Received */
4070+#define PCIE_RESR_FATAL_NOFATAL_ERR 0x00000004 /* ERR Fatal/Non-Fatal Received */
4071+#define PCIE_RESR_MULTI_FATAL_NOFATAL_ERR 0x00000008 /* Multiple ERR Fatal/Non-Fatal Received */
4072+#define PCIE_RESR_FIRST_UNCORRECTABLE_FATAL_ERR 0x00000010 /* First UN-COR Fatal */
4073+#define PCIR_RESR_NON_FATAL_ERR 0x00000020 /* Non-Fatal Error Message Received */
4074+#define PCIE_RESR_FATAL_ERR 0x00000040 /* Fatal Message Received */
4075+#define PCIE_RESR_AER_INT_MSG_NUM 0xF8000000 /* Advanced Error Interrupt Message Number */
4076+#define PCIE_RESR_AER_INT_MSG_NUM_S 27
4077+
4078+/* Error Source Indentification Register */
4079+#define PCIE_ESIR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x134)
4080+#define PCIE_ESIR_CORRECTABLE_ERR_SRC_ID 0x0000FFFF
4081+#define PCIE_ESIR_CORRECTABLE_ERR_SRC_ID_S 0
4082+#define PCIE_ESIR_FATAL_NON_FATAL_SRC_ID 0xFFFF0000
4083+#define PCIE_ESIR_FATAL_NON_FATAL_SRC_ID_S 16
4084+
4085+/* VC Enhanced Capability Header */
4086+#define PCIE_VC_ECH(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x140)
4087+
4088+/* Port VC Capability Register */
4089+#define PCIE_PVC1(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x144)
4090+#define PCIE_PVC1_EXT_VC_CNT 0x00000007 /* Extended VC Count */
4091+#define PCIE_PVC1_EXT_VC_CNT_S 0
4092+#define PCIE_PVC1_LOW_PRI_EXT_VC_CNT 0x00000070 /* Low Priority Extended VC Count */
4093+#define PCIE_PVC1_LOW_PRI_EXT_VC_CNT_S 4
4094+#define PCIE_PVC1_REF_CLK 0x00000300 /* Reference Clock */
4095+#define PCIE_PVC1_REF_CLK_S 8
4096+#define PCIE_PVC1_PORT_ARB_TAB_ENTRY_SIZE 0x00000C00 /* Port Arbitration Table Entry Size */
4097+#define PCIE_PVC1_PORT_ARB_TAB_ENTRY_SIZE_S 10
4098+
4099+/* Extended Virtual Channel Count Defintion */
4100+#define PCIE_EXT_VC_CNT_MIN 0
4101+#define PCIE_EXT_VC_CNT_MAX 7
4102+
4103+/* Port Arbitration Table Entry Size Definition */
4104+enum {
4105+ PCIE_PORT_ARB_TAB_ENTRY_SIZE_S1BIT = 0,
4106+ PCIE_PORT_ARB_TAB_ENTRY_SIZE_S2BIT,
4107+ PCIE_PORT_ARB_TAB_ENTRY_SIZE_S4BIT,
4108+ PCIE_PORT_ARB_TAB_ENTRY_SIZE_S8BIT,
4109+};
4110+
4111+/* Port VC Capability Register 2 */
4112+#define PCIE_PVC2(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x148)
4113+#define PCIE_PVC2_VC_ARB_16P_FIXED_WRR 0x00000001 /* HW Fixed arbitration, 16 phase WRR */
4114+#define PCIE_PVC2_VC_ARB_32P_WRR 0x00000002 /* 32 phase WRR */
4115+#define PCIE_PVC2_VC_ARB_64P_WRR 0x00000004 /* 64 phase WRR */
4116+#define PCIE_PVC2_VC_ARB_128P_WRR 0x00000008 /* 128 phase WRR */
4117+#define PCIE_PVC2_VC_ARB_WRR 0x0000000F
4118+#define PCIE_PVC2_VC_ARB_TAB_OFFSET 0xFF000000 /* VC arbitration table offset, not support */
4119+#define PCIE_PVC2_VC_ARB_TAB_OFFSET_S 24
4120+
4121+/* Port VC Control and Status Register */
4122+#define PCIE_PVCCRSR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x14C)
4123+#define PCIE_PVCCRSR_LOAD_VC_ARB_TAB 0x00000001 /* Load VC Arbitration Table */
4124+#define PCIE_PVCCRSR_VC_ARB_SEL 0x0000000E /* VC Arbitration Select */
4125+#define PCIE_PVCCRSR_VC_ARB_SEL_S 1
4126+#define PCIE_PVCCRSR_VC_ARB_TAB_STATUS 0x00010000 /* Arbitration Status */
4127+
4128+/* VC0 Resource Capability Register */
4129+#define PCIE_VC0_RC(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x150)
4130+#define PCIE_VC0_RC_PORT_ARB_HW_FIXED 0x00000001 /* HW Fixed arbitration */
4131+#define PCIE_VC0_RC_PORT_ARB_32P_WRR 0x00000002 /* 32 phase WRR */
4132+#define PCIE_VC0_RC_PORT_ARB_64P_WRR 0x00000004 /* 64 phase WRR */
4133+#define PCIE_VC0_RC_PORT_ARB_128P_WRR 0x00000008 /* 128 phase WRR */
4134+#define PCIE_VC0_RC_PORT_ARB_TM_128P_WRR 0x00000010 /* Time-based 128 phase WRR */
4135+#define PCIE_VC0_RC_PORT_ARB_TM_256P_WRR 0x00000020 /* Time-based 256 phase WRR */
4136+#define PCIE_VC0_RC_PORT_ARB (PCIE_VC0_RC_PORT_ARB_HW_FIXED | PCIE_VC0_RC_PORT_ARB_32P_WRR |\
4137+ PCIE_VC0_RC_PORT_ARB_64P_WRR | PCIE_VC0_RC_PORT_ARB_128P_WRR | \
4138+ PCIE_VC0_RC_PORT_ARB_TM_128P_WRR | PCIE_VC0_RC_PORT_ARB_TM_256P_WRR)
4139+
4140+#define PCIE_VC0_RC_REJECT_SNOOP 0x00008000 /* Reject Snoop Transactioin */
4141+#define PCIE_VC0_RC_MAX_TIMESLOTS 0x007F0000 /* Maximum time Slots */
4142+#define PCIE_VC0_RC_MAX_TIMESLOTS_S 16
4143+#define PCIE_VC0_RC_PORT_ARB_TAB_OFFSET 0xFF000000 /* Port Arbitration Table Offset */
4144+#define PCIE_VC0_RC_PORT_ARB_TAB_OFFSET_S 24
4145+
4146+/* VC0 Resource Control Register */
4147+#define PCIE_VC0_RC0(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x154)
4148+#define PCIE_VC0_RC0_TVM0 0x00000001 /* TC0 and VC0 */
4149+#define PCIE_VC0_RC0_TVM1 0x00000002 /* TC1 and VC1 */
4150+#define PCIE_VC0_RC0_TVM2 0x00000004 /* TC2 and VC2 */
4151+#define PCIE_VC0_RC0_TVM3 0x00000008 /* TC3 and VC3 */
4152+#define PCIE_VC0_RC0_TVM4 0x00000010 /* TC4 and VC4 */
4153+#define PCIE_VC0_RC0_TVM5 0x00000020 /* TC5 and VC5 */
4154+#define PCIE_VC0_RC0_TVM6 0x00000040 /* TC6 and VC6 */
4155+#define PCIE_VC0_RC0_TVM7 0x00000080 /* TC7 and VC7 */
4156+#define PCIE_VC0_RC0_TC_VC 0x000000FF /* TC/VC mask */
4157+
4158+#define PCIE_VC0_RC0_LOAD_PORT_ARB_TAB 0x00010000 /* Load Port Arbitration Table */
4159+#define PCIE_VC0_RC0_PORT_ARB_SEL 0x000E0000 /* Port Arbitration Select */
4160+#define PCIE_VC0_RC0_PORT_ARB_SEL_S 17
4161+#define PCIE_VC0_RC0_VC_ID 0x07000000 /* VC ID */
4162+#define PCIE_VC0_RC0_VC_ID_S 24
4163+#define PCIE_VC0_RC0_VC_EN 0x80000000 /* VC Enable */
4164+
4165+/* VC0 Resource Status Register */
4166+#define PCIE_VC0_RSR0(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x158)
4167+#define PCIE_VC0_RSR0_PORT_ARB_TAB_STATUS 0x00010000 /* Port Arbitration Table Status,not used */
4168+#define PCIE_VC0_RSR0_VC_NEG_PENDING 0x00020000 /* VC Negotiation Pending */
4169+
4170+/* Ack Latency Timer and Replay Timer Register */
4171+#define PCIE_ALTRT(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x700)
4172+#define PCIE_ALTRT_ROUND_TRIP_LATENCY_LIMIT 0x0000FFFF /* Round Trip Latency Time Limit */
4173+#define PCIE_ALTRT_ROUND_TRIP_LATENCY_LIMIT_S 0
4174+#define PCIE_ALTRT_REPLAY_TIME_LIMIT 0xFFFF0000 /* Replay Time Limit */
4175+#define PCIE_ALTRT_REPLAY_TIME_LIMIT_S 16
4176+
4177+/* Other Message Register */
4178+#define PCIE_OMR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x704)
4179+
4180+/* Port Force Link Register */
4181+#define PCIE_PFLR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x708)
4182+#define PCIE_PFLR_LINK_NUM 0x000000FF /* Link Number */
4183+#define PCIE_PFLR_LINK_NUM_S 0
4184+#define PCIE_PFLR_FORCE_LINK 0x00008000 /* Force link */
4185+#define PCIE_PFLR_LINK_STATE 0x003F0000 /* Link State */
4186+#define PCIE_PFLR_LINK_STATE_S 16
4187+#define PCIE_PFLR_LOW_POWER_ENTRY_CNT 0xFF000000 /* Low Power Entrance Count, only for EP */
4188+#define PCIE_PFLR_LOW_POWER_ENTRY_CNT_S 24
4189+
4190+/* Ack Frequency Register */
4191+#define PCIE_AFR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x70C)
4192+#define PCIE_AFR_AF 0x000000FF /* Ack Frequency */
4193+#define PCIE_AFR_AF_S 0
4194+#define PCIE_AFR_FTS_NUM 0x0000FF00 /* The number of Fast Training Sequence from L0S to L0 */
4195+#define PCIE_AFR_FTS_NUM_S 8
4196+#define PCIE_AFR_COM_FTS_NUM 0x00FF0000 /* N_FTS; when common clock is used*/
4197+#define PCIE_AFR_COM_FTS_NUM_S 16
4198+#define PCIE_AFR_L0S_ENTRY_LATENCY 0x07000000 /* L0s Entrance Latency */
4199+#define PCIE_AFR_L0S_ENTRY_LATENCY_S 24
4200+#define PCIE_AFR_L1_ENTRY_LATENCY 0x38000000 /* L1 Entrance Latency */
4201+#define PCIE_AFR_L1_ENTRY_LATENCY_S 27
4202+#define PCIE_AFR_FTS_NUM_DEFAULT 32
4203+#define PCIE_AFR_L0S_ENTRY_LATENCY_DEFAULT 7
4204+#define PCIE_AFR_L1_ENTRY_LATENCY_DEFAULT 5
4205+
4206+/* Port Link Control Register */
4207+#define PCIE_PLCR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x710)
4208+#define PCIE_PLCR_OTHER_MSG_REQ 0x00000001 /* Other Message Request */
4209+#define PCIE_PLCR_SCRAMBLE_DISABLE 0x00000002 /* Scramble Disable */
4210+#define PCIE_PLCR_LOOPBACK_EN 0x00000004 /* Loopback Enable */
4211+#define PCIE_PLCR_LTSSM_HOT_RST 0x00000008 /* Force LTSSM to the hot reset */
4212+#define PCIE_PLCR_DLL_LINK_EN 0x00000020 /* Enable Link initialization */
4213+#define PCIE_PLCR_FAST_LINK_SIM_EN 0x00000080 /* Sets all internal timers to fast mode for simulation purposes */
4214+#define PCIE_PLCR_LINK_MODE 0x003F0000 /* Link Mode Enable Mask */
4215+#define PCIE_PLCR_LINK_MODE_S 16
4216+#define PCIE_PLCR_CORRUPTED_CRC_EN 0x02000000 /* Enabled Corrupt CRC */
4217+
4218+/* Lane Skew Register */
4219+#define PCIE_LSR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x714)
4220+#define PCIE_LSR_LANE_SKEW_NUM 0x00FFFFFF /* Insert Lane Skew for Transmit, not applicable */
4221+#define PCIE_LSR_LANE_SKEW_NUM_S 0
4222+#define PCIE_LSR_FC_DISABLE 0x01000000 /* Disable of Flow Control */
4223+#define PCIE_LSR_ACKNAK_DISABLE 0x02000000 /* Disable of Ack/Nak */
4224+#define PCIE_LSR_LANE_DESKEW_DISABLE 0x80000000 /* Disable of Lane-to-Lane Skew */
4225+
4226+/* Symbol Number Register */
4227+#define PCIE_SNR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x718)
4228+#define PCIE_SNR_TS 0x0000000F /* Number of TS Symbol */
4229+#define PCIE_SNR_TS_S 0
4230+#define PCIE_SNR_SKP 0x00000700 /* Number of SKP Symbol */
4231+#define PCIE_SNR_SKP_S 8
4232+#define PCIE_SNR_REPLAY_TIMER 0x0007C000 /* Timer Modifier for Replay Timer */
4233+#define PCIE_SNR_REPLAY_TIMER_S 14
4234+#define PCIE_SNR_ACKNAK_LATENCY_TIMER 0x00F80000 /* Timer Modifier for Ack/Nak Latency Timer */
4235+#define PCIE_SNR_ACKNAK_LATENCY_TIMER_S 19
4236+#define PCIE_SNR_FC_TIMER 0x1F000000 /* Timer Modifier for Flow Control Watchdog Timer */
4237+#define PCIE_SNR_FC_TIMER_S 28
4238+
4239+/* Symbol Timer Register and Filter Mask Register 1 */
4240+#define PCIE_STRFMR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x71C)
4241+#define PCIE_STRFMR_SKP_INTERVAL 0x000007FF /* SKP lnterval Value */
4242+#define PCIE_STRFMR_SKP_INTERVAL_S 0
4243+#define PCIE_STRFMR_FC_WDT_DISABLE 0x00008000 /* Disable of FC Watchdog Timer */
4244+#define PCIE_STRFMR_TLP_FUNC_MISMATCH_OK 0x00010000 /* Mask Function Mismatch Filtering for Incoming Requests */
4245+#define PCIE_STRFMR_POISONED_TLP_OK 0x00020000 /* Mask Poisoned TLP Filtering */
4246+#define PCIE_STRFMR_BAR_MATCH_OK 0x00040000 /* Mask BAR Match Filtering */
4247+#define PCIE_STRFMR_TYPE1_CFG_REQ_OK 0x00080000 /* Mask Type 1 Configuration Request Filtering */
4248+#define PCIE_STRFMR_LOCKED_REQ_OK 0x00100000 /* Mask Locked Request Filtering */
4249+#define PCIE_STRFMR_CPL_TAG_ERR_RULES_OK 0x00200000 /* Mask Tag Error Rules for Received Completions */
4250+#define PCIE_STRFMR_CPL_REQUESTOR_ID_MISMATCH_OK 0x00400000 /* Mask Requester ID Mismatch Error for Received Completions */
4251+#define PCIE_STRFMR_CPL_FUNC_MISMATCH_OK 0x00800000 /* Mask Function Mismatch Error for Received Completions */
4252+#define PCIE_STRFMR_CPL_TC_MISMATCH_OK 0x01000000 /* Mask Traffic Class Mismatch Error for Received Completions */
4253+#define PCIE_STRFMR_CPL_ATTR_MISMATCH_OK 0x02000000 /* Mask Attribute Mismatch Error for Received Completions */
4254+#define PCIE_STRFMR_CPL_LENGTH_MISMATCH_OK 0x04000000 /* Mask Length Mismatch Error for Received Completions */
4255+#define PCIE_STRFMR_TLP_ECRC_ERR_OK 0x08000000 /* Mask ECRC Error Filtering */
4256+#define PCIE_STRFMR_CPL_TLP_ECRC_OK 0x10000000 /* Mask ECRC Error Filtering for Completions */
4257+#define PCIE_STRFMR_RX_TLP_MSG_NO_DROP 0x20000000 /* Send Message TLPs */
4258+#define PCIE_STRFMR_RX_IO_TRANS_ENABLE 0x40000000 /* Mask Filtering of received I/O Requests */
4259+#define PCIE_STRFMR_RX_CFG_TRANS_ENABLE 0x80000000 /* Mask Filtering of Received Configuration Requests */
4260+
4261+#define PCIE_DEF_SKP_INTERVAL 700 /* 1180 ~1538 , 125MHz * 2, 250MHz * 1 */
4262+
4263+/* Filter Masker Register 2 */
4264+#define PCIE_FMR2(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x720)
4265+#define PCIE_FMR2_VENDOR_MSG0_PASSED_TO_TRGT1 0x00000001 /* Mask RADM Filtering and Error Handling Rules */
4266+#define PCIE_FMR2_VENDOR_MSG1_PASSED_TO_TRGT1 0x00000002 /* Mask RADM Filtering and Error Handling Rules */
4267+
4268+/* Debug Register 0 */
4269+#define PCIE_DBR0(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x728)
4270+
4271+/* Debug Register 1 */
4272+#define PCIE_DBR1(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x72C)
4273+
4274+/* Transmit Posted FC Credit Status Register */
4275+#define PCIE_TPFCS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x730)
4276+#define PCIE_TPFCS_TX_P_DATA_FC_CREDITS 0x00000FFF /* Transmit Posted Data FC Credits */
4277+#define PCIE_TPFCS_TX_P_DATA_FC_CREDITS_S 0
4278+#define PCIE_TPFCS_TX_P_HDR_FC_CREDITS 0x000FF000 /* Transmit Posted Header FC Credits */
4279+#define PCIE_TPFCS_TX_P_HDR_FC_CREDITS_S 12
4280+
4281+/* Transmit Non-Posted FC Credit Status */
4282+#define PCIE_TNPFCS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x734)
4283+#define PCIE_TNPFCS_TX_NP_DATA_FC_CREDITS 0x00000FFF /* Transmit Non-Posted Data FC Credits */
4284+#define PCIE_TNPFCS_TX_NP_DATA_FC_CREDITS_S 0
4285+#define PCIE_TNPFCS_TX_NP_HDR_FC_CREDITS 0x000FF000 /* Transmit Non-Posted Header FC Credits */
4286+#define PCIE_TNPFCS_TX_NP_HDR_FC_CREDITS_S 12
4287+
4288+/* Transmit Complete FC Credit Status Register */
4289+#define PCIE_TCFCS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x738)
4290+#define PCIE_TCFCS_TX_CPL_DATA_FC_CREDITS 0x00000FFF /* Transmit Completion Data FC Credits */
4291+#define PCIE_TCFCS_TX_CPL_DATA_FC_CREDITS_S 0
4292+#define PCIE_TCFCS_TX_CPL_HDR_FC_CREDITS 0x000FF000 /* Transmit Completion Header FC Credits */
4293+#define PCIE_TCFCS_TX_CPL_HDR_FC_CREDITS_S 12
4294+
4295+/* Queue Status Register */
4296+#define PCIE_QSR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x73C)
4297+#define PCIE_QSR_WAIT_UPDATE_FC_DLL 0x00000001 /* Received TLP FC Credits Not Returned */
4298+#define PCIE_QSR_TX_RETRY_BUF_NOT_EMPTY 0x00000002 /* Transmit Retry Buffer Not Empty */
4299+#define PCIE_QSR_RX_QUEUE_NOT_EMPTY 0x00000004 /* Received Queue Not Empty */
4300+
4301+/* VC Transmit Arbitration Register 1 */
4302+#define PCIE_VCTAR1(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x740)
4303+#define PCIE_VCTAR1_WRR_WEIGHT_VC0 0x000000FF /* WRR Weight for VC0 */
4304+#define PCIE_VCTAR1_WRR_WEIGHT_VC1 0x0000FF00 /* WRR Weight for VC1 */
4305+#define PCIE_VCTAR1_WRR_WEIGHT_VC2 0x00FF0000 /* WRR Weight for VC2 */
4306+#define PCIE_VCTAR1_WRR_WEIGHT_VC3 0xFF000000 /* WRR Weight for VC3 */
4307+
4308+/* VC Transmit Arbitration Register 2 */
4309+#define PCIE_VCTAR2(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x744)
4310+#define PCIE_VCTAR2_WRR_WEIGHT_VC4 0x000000FF /* WRR Weight for VC4 */
4311+#define PCIE_VCTAR2_WRR_WEIGHT_VC5 0x0000FF00 /* WRR Weight for VC5 */
4312+#define PCIE_VCTAR2_WRR_WEIGHT_VC6 0x00FF0000 /* WRR Weight for VC6 */
4313+#define PCIE_VCTAR2_WRR_WEIGHT_VC7 0xFF000000 /* WRR Weight for VC7 */
4314+
4315+/* VC0 Posted Receive Queue Control Register */
4316+#define PCIE_VC0_PRQCR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x748)
4317+#define PCIE_VC0_PRQCR_P_DATA_CREDITS 0x00000FFF /* VC0 Posted Data Credits */
4318+#define PCIE_VC0_PRQCR_P_DATA_CREDITS_S 0
4319+#define PCIE_VC0_PRQCR_P_HDR_CREDITS 0x000FF000 /* VC0 Posted Header Credits */
4320+#define PCIE_VC0_PRQCR_P_HDR_CREDITS_S 12
4321+#define PCIE_VC0_PRQCR_P_TLP_QUEUE_MODE 0x00E00000 /* VC0 Posted TLP Queue Mode */
4322+#define PCIE_VC0_PRQCR_P_TLP_QUEUE_MODE_S 20
4323+#define PCIE_VC0_PRQCR_TLP_RELAX_ORDER 0x40000000 /* TLP Type Ordering for VC0 */
4324+#define PCIE_VC0_PRQCR_VC_STRICT_ORDER 0x80000000 /* VC0 Ordering for Receive Queues */
4325+
4326+/* VC0 Non-Posted Receive Queue Control */
4327+#define PCIE_VC0_NPRQCR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x74C)
4328+#define PCIE_VC0_NPRQCR_NP_DATA_CREDITS 0x00000FFF /* VC0 Non-Posted Data Credits */
4329+#define PCIE_VC0_NPRQCR_NP_DATA_CREDITS_S 0
4330+#define PCIE_VC0_NPRQCR_NP_HDR_CREDITS 0x000FF000 /* VC0 Non-Posted Header Credits */
4331+#define PCIE_VC0_NPRQCR_NP_HDR_CREDITS_S 12
4332+#define PCIE_VC0_NPRQCR_NP_TLP_QUEUE_MODE 0x00E00000 /* VC0 Non-Posted TLP Queue Mode */
4333+#define PCIE_VC0_NPRQCR_NP_TLP_QUEUE_MODE_S 20
4334+
4335+/* VC0 Completion Receive Queue Control */
4336+#define PCIE_VC0_CRQCR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x750)
4337+#define PCIE_VC0_CRQCR_CPL_DATA_CREDITS 0x00000FFF /* VC0 Completion TLP Queue Mode */
4338+#define PCIE_VC0_CRQCR_CPL_DATA_CREDITS_S 0
4339+#define PCIE_VC0_CRQCR_CPL_HDR_CREDITS 0x000FF000 /* VC0 Completion Header Credits */
4340+#define PCIE_VC0_CRQCR_CPL_HDR_CREDITS_S 12
4341+#define PCIE_VC0_CRQCR_CPL_TLP_QUEUE_MODE 0x00E00000 /* VC0 Completion Data Credits */
4342+#define PCIE_VC0_CRQCR_CPL_TLP_QUEUE_MODE_S 21
4343+
4344+/* Applicable to the above three registers */
4345+enum {
4346+ PCIE_VC0_TLP_QUEUE_MODE_STORE_FORWARD = 1,
4347+ PCIE_VC0_TLP_QUEUE_MODE_CUT_THROUGH = 2,
4348+ PCIE_VC0_TLP_QUEUE_MODE_BYPASS = 4,
4349+};
4350+
4351+/* VC0 Posted Buffer Depth Register */
4352+#define PCIE_VC0_PBD(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x7A8)
4353+#define PCIE_VC0_PBD_P_DATA_QUEUE_ENTRIES 0x00003FFF /* VC0 Posted Data Queue Depth */
4354+#define PCIE_VC0_PBD_P_DATA_QUEUE_ENTRIES_S 0
4355+#define PCIE_VC0_PBD_P_HDR_QUEUE_ENTRIES 0x03FF0000 /* VC0 Posted Header Queue Depth */
4356+#define PCIE_VC0_PBD_P_HDR_QUEUE_ENTRIES_S 16
4357+
4358+/* VC0 Non-Posted Buffer Depth Register */
4359+#define PCIE_VC0_NPBD(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x7AC)
4360+#define PCIE_VC0_NPBD_NP_DATA_QUEUE_ENTRIES 0x00003FFF /* VC0 Non-Posted Data Queue Depth */
4361+#define PCIE_VC0_NPBD_NP_DATA_QUEUE_ENTRIES_S 0
4362+#define PCIE_VC0_NPBD_NP_HDR_QUEUE_ENTRIES 0x03FF0000 /* VC0 Non-Posted Header Queue Depth */
4363+#define PCIE_VC0_NPBD_NP_HDR_QUEUE_ENTRIES_S 16
4364+
4365+/* VC0 Completion Buffer Depth Register */
4366+#define PCIE_VC0_CBD(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x7B0)
4367+#define PCIE_VC0_CBD_CPL_DATA_QUEUE_ENTRIES 0x00003FFF /* C0 Completion Data Queue Depth */
4368+#define PCIE_VC0_CBD_CPL_DATA_QUEUE_ENTRIES_S 0
4369+#define PCIE_VC0_CBD_CPL_HDR_QUEUE_ENTRIES 0x03FF0000 /* VC0 Completion Header Queue Depth */
4370+#define PCIE_VC0_CBD_CPL_HDR_QUEUE_ENTRIES_S 16
4371+
4372+/* PHY Status Register, all zeros in VR9 */
4373+#define PCIE_PHYSR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x810)
4374+
4375+/* PHY Control Register, all zeros in VR9 */
4376+#define PCIE_PHYCR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x814)
4377+
4378+/*
4379+ * PCIe PDI PHY register definition, suppose all the following
4380+ * stuff is confidential.
4381+ * XXX, detailed bit definition
4382+ */
4383+#define PCIE_PHY_PLL_CTRL1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x22 << 1))
4384+#define PCIE_PHY_PLL_CTRL2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x23 << 1))
4385+#define PCIE_PHY_PLL_CTRL3(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x24 << 1))
4386+#define PCIE_PHY_PLL_CTRL4(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x25 << 1))
4387+#define PCIE_PHY_PLL_CTRL5(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x26 << 1))
4388+#define PCIE_PHY_PLL_CTRL6(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x27 << 1))
4389+#define PCIE_PHY_PLL_CTRL7(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x28 << 1))
4390+#define PCIE_PHY_PLL_A_CTRL1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x29 << 1))
4391+#define PCIE_PHY_PLL_A_CTRL2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x2A << 1))
4392+#define PCIE_PHY_PLL_A_CTRL3(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x2B << 1))
4393+#define PCIE_PHY_PLL_STATUS(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x2C << 1))
4394+
4395+#define PCIE_PHY_TX1_CTRL1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x30 << 1))
4396+#define PCIE_PHY_TX1_CTRL2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x31 << 1))
4397+#define PCIE_PHY_TX1_CTRL3(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x32 << 1))
4398+#define PCIE_PHY_TX1_A_CTRL1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x33 << 1))
4399+#define PCIE_PHY_TX1_A_CTRL2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x34 << 1))
4400+#define PCIE_PHY_TX1_MOD1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x35 << 1))
4401+#define PCIE_PHY_TX1_MOD2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x36 << 1))
4402+#define PCIE_PHY_TX1_MOD3(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x37 << 1))
4403+
4404+#define PCIE_PHY_TX2_CTRL1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x38 << 1))
4405+#define PCIE_PHY_TX2_CTRL2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x39 << 1))
4406+#define PCIE_PHY_TX2_A_CTRL1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x3B << 1))
4407+#define PCIE_PHY_TX2_A_CTRL2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x3C << 1))
4408+#define PCIE_PHY_TX2_MOD1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x3D << 1))
4409+#define PCIE_PHY_TX2_MOD2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x3E << 1))
4410+#define PCIE_PHY_TX2_MOD3(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x3F << 1))
4411+
4412+#define PCIE_PHY_RX1_CTRL1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x50 << 1))
4413+#define PCIE_PHY_RX1_CTRL2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x51 << 1))
4414+#define PCIE_PHY_RX1_CDR(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x52 << 1))
4415+#define PCIE_PHY_RX1_EI(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x53 << 1))
4416+#define PCIE_PHY_RX1_A_CTRL(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x55 << 1))
4417+
4418+/* Interrupt related stuff */
4419+#define PCIE_LEGACY_DISABLE 0
4420+#define PCIE_LEGACY_INTA 1
4421+#define PCIE_LEGACY_INTB 2
4422+#define PCIE_LEGACY_INTC 3
4423+#define PCIE_LEGACY_INTD 4
4424+#define PCIE_LEGACY_INT_MAX PCIE_LEGACY_INTD
4425+
4426+#endif /* IFXMIPS_PCIE_REG_H */
4427+
4428diff --git a/arch/mips/pci/ifxmips_pcie_vr9.h b/arch/mips/pci/ifxmips_pcie_vr9.h
4429new file mode 100644
4430index 0000000..57d9368
4431--- /dev/null
4432+++ b/arch/mips/pci/ifxmips_pcie_vr9.h
4433@@ -0,0 +1,271 @@
4434+/****************************************************************************
4435+ Copyright (c) 2010
4436+ Lantiq Deutschland GmbH
4437+ Am Campeon 3; 85579 Neubiberg, Germany
4438+
4439+ For licensing information, see the file 'LICENSE' in the root folder of
4440+ this software module.
4441+
4442+ *****************************************************************************/
4443+/*!
4444+ \file ifxmips_pcie_vr9.h
4445+ \ingroup IFX_PCIE
4446+ \brief PCIe RC driver vr9 specific file
4447+*/
4448+
4449+#ifndef IFXMIPS_PCIE_VR9_H
4450+#define IFXMIPS_PCIE_VR9_H
4451+
4452+#include <linux/types.h>
4453+#include <linux/delay.h>
4454+
4455+#include <linux/gpio.h>
4456+#include <lantiq_soc.h>
4457+
4458+#define IFX_PCIE_GPIO_RESET 238
4459+
4460+#define IFX_REG_R32 ltq_r32
4461+#define IFX_REG_W32 ltq_w32
4462+#define CONFIG_IFX_PCIE_HW_SWAP
4463+#define IFX_RCU_AHB_ENDIAN ((volatile u32*)(IFX_RCU + 0x004C))
4464+#define IFX_RCU_RST_REQ ((volatile u32*)(IFX_RCU + 0x0010))
4465+#define IFX_RCU_AHB_BE_PCIE_PDI 0x00000080 /* Configure PCIE PDI module in big endian*/
4466+
4467+#define IFX_RCU (KSEG1 | 0x1F203000)
4468+#define IFX_RCU_AHB_BE_PCIE_M 0x00000001 /* Configure AHB master port that connects to PCIe RC in big endian */
4469+#define IFX_RCU_AHB_BE_PCIE_S 0x00000010 /* Configure AHB slave port that connects to PCIe RC in little endian */
4470+#define IFX_RCU_AHB_BE_XBAR_M 0x00000002 /* Configure AHB master port that connects to XBAR in big endian */
4471+#define CONFIG_IFX_PCIE_PHY_36MHZ_MODE
4472+
4473+#define IFX_PMU1_MODULE_PCIE_PHY (0)
4474+#define IFX_PMU1_MODULE_PCIE_CTRL (1)
4475+#define IFX_PMU1_MODULE_PDI (4)
4476+#define IFX_PMU1_MODULE_MSI (5)
4477+
4478+#define IFX_PMU_MODULE_PCIE_L0_CLK (31)
4479+
4480+
4481+#define IFX_GPIO (KSEG1 | 0x1E100B00)
4482+#define ALT0 ((volatile u32*)(IFX_GPIO + 0x007c))
4483+#define ALT1 ((volatile u32*)(IFX_GPIO + 0x0080))
4484+#define OD ((volatile u32*)(IFX_GPIO + 0x0084))
4485+#define DIR ((volatile u32*)(IFX_GPIO + 0x0078))
4486+#define OUT ((volatile u32*)(IFX_GPIO + 0x0070))
4487+
4488+
4489+static inline void pcie_ep_gpio_rst_init(int pcie_port)
4490+{
4491+
4492+ gpio_request(IFX_PCIE_GPIO_RESET, "pcie-reset");
4493+ gpio_direction_output(IFX_PCIE_GPIO_RESET, 1);
4494+ gpio_set_value(IFX_PCIE_GPIO_RESET, 1);
4495+
4496+/* ifx_gpio_pin_reserve(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
4497+ ifx_gpio_output_set(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
4498+ ifx_gpio_dir_out_set(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
4499+ ifx_gpio_altsel0_clear(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
4500+ ifx_gpio_altsel1_clear(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
4501+ ifx_gpio_open_drain_set(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);*/
4502+}
4503+
4504+static inline void pcie_ahb_pmu_setup(void)
4505+{
4506+ /* Enable AHB bus master/slave */
4507+ struct clk *clk;
4508+ clk = clk_get_sys("1d900000.pcie", "ahb");
4509+ clk_enable(clk);
4510+
4511+ //AHBM_PMU_SETUP(IFX_PMU_ENABLE);
4512+ //AHBS_PMU_SETUP(IFX_PMU_ENABLE);
4513+}
4514+
4515+static inline void pcie_rcu_endian_setup(int pcie_port)
4516+{
4517+ u32 reg;
4518+
4519+ reg = IFX_REG_R32(IFX_RCU_AHB_ENDIAN);
4520+#ifdef CONFIG_IFX_PCIE_HW_SWAP
4521+ reg |= IFX_RCU_AHB_BE_PCIE_M;
4522+ reg |= IFX_RCU_AHB_BE_PCIE_S;
4523+ reg &= ~IFX_RCU_AHB_BE_XBAR_M;
4524+#else
4525+ reg |= IFX_RCU_AHB_BE_PCIE_M;
4526+ reg &= ~IFX_RCU_AHB_BE_PCIE_S;
4527+ reg &= ~IFX_RCU_AHB_BE_XBAR_M;
4528+#endif /* CONFIG_IFX_PCIE_HW_SWAP */
4529+ IFX_REG_W32(reg, IFX_RCU_AHB_ENDIAN);
4530+ IFX_PCIE_PRINT(PCIE_MSG_REG, "%s IFX_RCU_AHB_ENDIAN: 0x%08x\n", __func__, IFX_REG_R32(IFX_RCU_AHB_ENDIAN));
4531+}
4532+
4533+static inline void pcie_phy_pmu_enable(int pcie_port)
4534+{
4535+ struct clk *clk;
4536+ clk = clk_get_sys("1d900000.pcie", "phy");
4537+ clk_enable(clk);
4538+
4539+ //PCIE_PHY_PMU_SETUP(IFX_PMU_ENABLE);
4540+}
4541+
4542+static inline void pcie_phy_pmu_disable(int pcie_port)
4543+{
4544+ struct clk *clk;
4545+ clk = clk_get_sys("1d900000.pcie", "phy");
4546+ clk_disable(clk);
4547+
4548+// PCIE_PHY_PMU_SETUP(IFX_PMU_DISABLE);
4549+}
4550+
4551+static inline void pcie_pdi_big_endian(int pcie_port)
4552+{
4553+ u32 reg;
4554+
4555+ /* SRAM2PDI endianness control. */
4556+ reg = IFX_REG_R32(IFX_RCU_AHB_ENDIAN);
4557+ /* Config AHB->PCIe and PDI endianness */
4558+ reg |= IFX_RCU_AHB_BE_PCIE_PDI;
4559+ IFX_REG_W32(reg, IFX_RCU_AHB_ENDIAN);
4560+}
4561+
4562+static inline void pcie_pdi_pmu_enable(int pcie_port)
4563+{
4564+ /* Enable PDI to access PCIe PHY register */
4565+ struct clk *clk;
4566+ clk = clk_get_sys("1d900000.pcie", "pdi");
4567+ clk_enable(clk);
4568+ //PDI_PMU_SETUP(IFX_PMU_ENABLE);
4569+}
4570+
4571+static inline void pcie_core_rst_assert(int pcie_port)
4572+{
4573+ u32 reg;
4574+
4575+ reg = IFX_REG_R32(IFX_RCU_RST_REQ);
4576+
4577+ /* Reset PCIe PHY & Core, bit 22, bit 26 may be affected if write it directly */
4578+ reg |= 0x00400000;
4579+ IFX_REG_W32(reg, IFX_RCU_RST_REQ);
4580+}
4581+
4582+static inline void pcie_core_rst_deassert(int pcie_port)
4583+{
4584+ u32 reg;
4585+
4586+ /* Make sure one micro-second delay */
4587+ udelay(1);
4588+
4589+ /* Reset PCIe PHY & Core, bit 22 */
4590+ reg = IFX_REG_R32(IFX_RCU_RST_REQ);
4591+ reg &= ~0x00400000;
4592+ IFX_REG_W32(reg, IFX_RCU_RST_REQ);
4593+}
4594+
4595+static inline void pcie_phy_rst_assert(int pcie_port)
4596+{
4597+ u32 reg;
4598+
4599+ reg = IFX_REG_R32(IFX_RCU_RST_REQ);
4600+ reg |= 0x00001000; /* Bit 12 */
4601+ IFX_REG_W32(reg, IFX_RCU_RST_REQ);
4602+}
4603+
4604+static inline void pcie_phy_rst_deassert(int pcie_port)
4605+{
4606+ u32 reg;
4607+
4608+ /* Make sure one micro-second delay */
4609+ udelay(1);
4610+
4611+ reg = IFX_REG_R32(IFX_RCU_RST_REQ);
4612+ reg &= ~0x00001000; /* Bit 12 */
4613+ IFX_REG_W32(reg, IFX_RCU_RST_REQ);
4614+}
4615+
4616+static inline void pcie_device_rst_assert(int pcie_port)
4617+{
4618+ printk("%s:%s[%d]\n", __FILE__, __func__, __LINE__);
4619+ gpio_set_value(IFX_PCIE_GPIO_RESET, 0);
4620+// ifx_gpio_output_clear(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
4621+}
4622+
4623+static inline void pcie_device_rst_deassert(int pcie_port)
4624+{
4625+ mdelay(100);
4626+ printk("%s:%s[%d]\n", __FILE__, __func__, __LINE__);
4627+ gpio_direction_output(IFX_PCIE_GPIO_RESET, 1);
4628+// gpio_set_value(IFX_PCIE_GPIO_RESET, 1);
4629+ //ifx_gpio_output_set(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
4630+}
4631+
4632+static inline void pcie_core_pmu_setup(int pcie_port)
4633+{
4634+ struct clk *clk;
4635+ clk = clk_get_sys("1d900000.pcie", "ctl");
4636+ clk_enable(clk);
4637+ clk = clk_get_sys("1d900000.pcie", "bus");
4638+ clk_enable(clk);
4639+
4640+ /* PCIe Core controller enabled */
4641+// PCIE_CTRL_PMU_SETUP(IFX_PMU_ENABLE);
4642+
4643+ /* Enable PCIe L0 Clock */
4644+// PCIE_L0_CLK_PMU_SETUP(IFX_PMU_ENABLE);
4645+}
4646+
4647+static inline void pcie_msi_init(int pcie_port)
4648+{
4649+ struct clk *clk;
4650+ pcie_msi_pic_init(pcie_port);
4651+ clk = clk_get_sys("ltq_pcie", "msi");
4652+ clk_enable(clk);
4653+// MSI_PMU_SETUP(IFX_PMU_ENABLE);
4654+}
4655+
4656+static inline u32
4657+ifx_pcie_bus_nr_deduct(u32 bus_number, int pcie_port)
4658+{
4659+ u32 tbus_number = bus_number;
4660+
4661+#ifdef CONFIG_IFX_PCI
4662+ if (pcibios_host_nr() > 1) {
4663+ tbus_number -= pcibios_1st_host_bus_nr();
4664+ }
4665+#endif /* CONFIG_IFX_PCI */
4666+ return tbus_number;
4667+}
4668+
4669+static inline u32
4670+ifx_pcie_bus_enum_hack(struct pci_bus *bus, u32 devfn, int where, u32 value, int pcie_port, int read)
4671+{
4672+ struct pci_dev *pdev;
4673+ u32 tvalue = value;
4674+
4675+ /* Sanity check */
4676+ pdev = pci_get_slot(bus, devfn);
4677+ if (pdev == NULL) {
4678+ return tvalue;
4679+ }
4680+
4681+ /* Only care about PCI bridge */
4682+ if (pdev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
4683+ return tvalue;
4684+ }
4685+
4686+ if (read) { /* Read hack */
4687+ #ifdef CONFIG_IFX_PCI
4688+ if (pcibios_host_nr() > 1) {
4689+ tvalue = ifx_pcie_bus_enum_read_hack(where, tvalue);
4690+ }
4691+ #endif /* CONFIG_IFX_PCI */
4692+ }
4693+ else { /* Write hack */
4694+ #ifdef CONFIG_IFX_PCI
4695+ if (pcibios_host_nr() > 1) {
4696+ tvalue = ifx_pcie_bus_enum_write_hack(where, tvalue);
4697+ }
4698+ #endif
4699+ }
4700+ return tvalue;
4701+}
4702+
4703+#endif /* IFXMIPS_PCIE_VR9_H */
4704+
4705diff --git a/arch/mips/pci/pci.c b/arch/mips/pci/pci.c
4706index 04e35bc..2e85529 100644
4707--- a/arch/mips/pci/pci.c
4708+++ b/arch/mips/pci/pci.c
4709@@ -250,6 +250,31 @@ static int __init pcibios_init(void)
4710 
4711 subsys_initcall(pcibios_init);
4712 
4713+int pcibios_host_nr(void)
4714+{
4715+ int count;
4716+ struct pci_controller *hose;
4717+ for (count = 0, hose = hose_head; hose; hose = hose->next, count++) {
4718+ ;
4719+ }
4720+ return count;
4721+}
4722+EXPORT_SYMBOL(pcibios_host_nr);
4723+
4724+int pcibios_1st_host_bus_nr(void)
4725+{
4726+ int bus_nr = 0;
4727+ struct pci_controller *hose = hose_head;
4728+
4729+ if (hose != NULL) {
4730+ if (hose->bus != NULL) {
4731+ bus_nr = hose->bus->number + 1;
4732+ }
4733+ }
4734+ return bus_nr;
4735+}
4736+EXPORT_SYMBOL(pcibios_1st_host_bus_nr);
4737+
4738 static int pcibios_enable_resources(struct pci_dev *dev, int mask)
4739 {
4740     u16 cmd, old_cmd;
4741diff --git a/drivers/pci/pcie/aer/Kconfig b/drivers/pci/pcie/aer/Kconfig
4742index 50e94e0..4bf848f 100644
4743--- a/drivers/pci/pcie/aer/Kconfig
4744+++ b/drivers/pci/pcie/aer/Kconfig
4745@@ -5,7 +5,7 @@
4746 config PCIEAER
4747     boolean "Root Port Advanced Error Reporting support"
4748     depends on PCIEPORTBUS
4749- default y
4750+ default n
4751     help
4752       This enables PCI Express Root Port Advanced Error Reporting
4753       (AER) driver support. Error reporting messages sent to Root
4754diff --git a/include/linux/pci.h b/include/linux/pci.h
4755index ee21795..0d08026 100644
4756--- a/include/linux/pci.h
4757+++ b/include/linux/pci.h
4758@@ -1038,6 +1038,8 @@ void pci_walk_bus(struct pci_bus *top, int (*cb)(struct pci_dev *, void *),
4759 int pci_cfg_space_size_ext(struct pci_dev *dev);
4760 int pci_cfg_space_size(struct pci_dev *dev);
4761 unsigned char pci_bus_max_busnr(struct pci_bus *bus);
4762+int pcibios_host_nr(void);
4763+int pcibios_1st_host_bus_nr(void);
4764 void pci_setup_bridge(struct pci_bus *bus);
4765 resource_size_t pcibios_window_alignment(struct pci_bus *bus,
4766                      unsigned long type);
4767diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
4768index 9d36b82..493ada4 100644
4769--- a/include/linux/pci_ids.h
4770+++ b/include/linux/pci_ids.h
4771@@ -1040,6 +1040,12 @@
4772 #define PCI_DEVICE_ID_SGI_LITHIUM 0x1002
4773 #define PCI_DEVICE_ID_SGI_IOC4 0x100a
4774 
4775+#define PCI_VENDOR_ID_INFINEON 0x15D1
4776+#define PCI_DEVICE_ID_INFINEON_DANUBE 0x000F
4777+#define PCI_DEVICE_ID_INFINEON_PCIE 0x0011
4778+#define PCI_VENDOR_ID_LANTIQ 0x1BEF
4779+#define PCI_DEVICE_ID_LANTIQ_PCIE 0x00
4780+
4781 #define PCI_VENDOR_ID_WINBOND 0x10ad
4782 #define PCI_DEVICE_ID_WINBOND_82C105 0x0105
4783 #define PCI_DEVICE_ID_WINBOND_83C553 0x0565
4784--
47851.7.10.4
4786
4787

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive