1 From b0b68cd5b5da72950863af882c368f28f65690e8 Mon Sep 17 00:00:00 2001
2 From: John Crispin <blogic@openwrt.org>
3 Date: Thu, 6 Dec 2012 11:43:53 +0100
4 Subject: [PATCH 122/123] MIPS: lantiq: adds pcie driver
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
39 --- a/arch/mips/lantiq/Kconfig
40 +++ b/arch/mips/lantiq/Kconfig
41 @@ -17,6 +17,7 @@ config SOC_XWAY
45 + select ARCH_SUPPORTS_MSI
49 @@ -40,6 +41,15 @@ config PCI_LANTIQ
51 depends on SOC_XWAY && PCI
55 + depends on SOC_XWAY && PCI
57 +config PCIE_LANTIQ_MSI
59 + depends on PCIE_LANTIQ && PCI_MSI
63 bool "XRX200 PHY firmware loader"
65 --- a/arch/mips/lantiq/xway/sysctrl.c
66 +++ b/arch/mips/lantiq/xway/sysctrl.c
67 @@ -377,6 +377,8 @@ void __init ltq_soc_init(void)
68 PMU_PPE_EMA | PMU_PPE_TC | PMU_PPE_SLL01 |
69 PMU_PPE_QSB | PMU_PPE_TOP);
70 clkdev_add_pmu("1f203000.rcu", "gphy", 0, PMU_GPHY);
71 + pmu_w32(~0, PMU_PWDSR1);
72 + pmu_w32(pmu_r32(PMU_PWDSR) & ~PMU_PCIE_CLK, PMU_PWDSR);
73 } else if (of_machine_is_compatible("lantiq,ar9")) {
74 clkdev_add_static(ltq_ar9_cpu_hz(), ltq_ar9_fpi_hz(),
75 ltq_ar9_fpi_hz(), CLOCK_250M);
76 --- a/arch/mips/pci/Makefile
77 +++ b/arch/mips/pci/Makefile
78 @@ -44,6 +44,8 @@ obj-$(CONFIG_SIBYTE_BCM1x80) += pci-bcm1
79 obj-$(CONFIG_SNI_RM) += fixup-sni.o ops-sni.o
80 obj-$(CONFIG_LANTIQ) += fixup-lantiq.o
81 obj-$(CONFIG_PCI_LANTIQ) += pci-lantiq.o ops-lantiq.o
82 +obj-$(CONFIG_PCIE_LANTIQ) += ifxmips_pcie_phy.o ifxmips_pcie.o fixup-lantiq-pcie.o
83 +obj-$(CONFIG_PCIE_LANTIQ_MSI) += pcie-lantiq-msi.o
84 obj-$(CONFIG_TANBAC_TB0219) += fixup-tb0219.o
85 obj-$(CONFIG_TANBAC_TB0226) += fixup-tb0226.o
86 obj-$(CONFIG_TANBAC_TB0287) += fixup-tb0287.o
88 +++ b/arch/mips/pci/fixup-lantiq-pcie.c
90 +/******************************************************************************
92 +** FILE NAME : ifxmips_fixup_pcie.c
93 +** PROJECT : IFX UEIP for VRX200
96 +** DATE : 02 Mar 2009
97 +** AUTHOR : Lei Chuanhua
98 +** DESCRIPTION : PCIe Root Complex Driver
99 +** COPYRIGHT : Copyright (c) 2009
100 +** Infineon Technologies AG
101 +** Am Campeon 1-12, 85579 Neubiberg, Germany
103 +** This program is free software; you can redistribute it and/or modify
104 +** it under the terms of the GNU General Public License as published by
105 +** the Free Software Foundation; either version 2 of the License, or
106 +** (at your option) any later version.
108 +** $Version $Date $Author $Comment
109 +** 0.0.1 17 Mar,2009 Lei Chuanhua Initial version
110 +*******************************************************************************/
112 + \file ifxmips_fixup_pcie.c
114 + \brief PCIe Fixup functions source file
116 +#include <linux/pci.h>
117 +#include <linux/pci_regs.h>
118 +#include <linux/pci_ids.h>
120 +#include <lantiq_soc.h>
122 +#include "pcie-lantiq.h"
124 +#define PCI_VENDOR_ID_INFINEON 0x15D1
125 +#define PCI_DEVICE_ID_INFINEON_DANUBE 0x000F
126 +#define PCI_DEVICE_ID_INFINEON_PCIE 0x0011
127 +#define PCI_VENDOR_ID_LANTIQ 0x1BEF
128 +#define PCI_DEVICE_ID_LANTIQ_PCIE 0x0011
132 +static void __devinit
133 +ifx_pcie_fixup_resource(struct pci_dev *dev)
137 + IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s dev %s: enter\n", __func__, pci_name(dev));
139 + printk("%s: fixup host controller %s (%04x:%04x)\n",
140 + __func__, pci_name(dev), dev->vendor, dev->device);
142 + /* Setup COMMAND register */
143 + reg = PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER /* |
144 + PCI_COMMAND_INTX_DISABLE */| PCI_COMMAND_SERR;
145 + pci_write_config_word(dev, PCI_COMMAND, reg);
146 + IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s dev %s: exit\n", __func__, pci_name(dev));
148 +DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INFINEON, PCI_DEVICE_ID_INFINEON_PCIE, ifx_pcie_fixup_resource);
149 +DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_LANTIQ, PCI_VENDOR_ID_LANTIQ, ifx_pcie_fixup_resource);
151 +static void __devinit
152 +ifx_pcie_rc_class_early_fixup(struct pci_dev *dev)
154 + IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s dev %s: enter\n", __func__, pci_name(dev));
156 + if (dev->devfn == PCI_DEVFN(0, 0) &&
157 + (dev->class >> 8) == PCI_CLASS_BRIDGE_HOST) {
159 + dev->class = (PCI_CLASS_BRIDGE_PCI << 8) | (dev->class & 0xff);
161 + printk(KERN_INFO "%s: fixed pcie host bridge to pci-pci bridge\n", __func__);
163 + IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s dev %s: exit\n", __func__, pci_name(dev));
167 +DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INFINEON, PCI_DEVICE_ID_INFINEON_PCIE,
168 + ifx_pcie_rc_class_early_fixup);
170 +DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_LANTIQ, PCI_DEVICE_ID_LANTIQ_PCIE,
171 + ifx_pcie_rc_class_early_fixup);
172 --- a/arch/mips/pci/fixup-lantiq.c
173 +++ b/arch/mips/pci/fixup-lantiq.c
176 int (*ltq_pci_plat_arch_init)(struct pci_dev *dev) = NULL;
177 int (*ltq_pci_plat_dev_init)(struct pci_dev *dev) = NULL;
178 +int (*ltq_pci_map_irq)(const struct pci_dev *dev, u8 slot, u8 pin);
180 int pcibios_plat_dev_init(struct pci_dev *dev)
182 @@ -28,6 +29,8 @@ int __init pcibios_map_irq(const struct
183 struct of_irq dev_irq;
186 + if (ltq_pci_map_irq)
187 + return ltq_pci_map_irq(dev, slot, pin);
188 if (of_irq_map_pci(dev, &dev_irq)) {
189 dev_err(&dev->dev, "trying to map irq for unknown slot:%d pin:%d\n",
192 +++ b/arch/mips/pci/ifxmips_pci_common.h
194 +/******************************************************************************
\r
196 +** FILE NAME : ifxmips_pci_common.h
\r
197 +** PROJECT : IFX UEIP
\r
198 +** MODULES : PCI subsystem
\r
200 +** DATE : 30 June 2009
\r
201 +** AUTHOR : Lei Chuanhua
\r
202 +** DESCRIPTION : PCIe Root Complex Driver
\r
203 +** COPYRIGHT : Copyright (c) 2009
\r
204 +** Infineon Technologies AG
\r
205 +** Am Campeon 1-12, 85579 Neubiberg, Germany
\r
207 +** This program is free software; you can redistribute it and/or modify
\r
208 +** it under the terms of the GNU General Public License as published by
\r
209 +** the Free Software Foundation; either version 2 of the License, or
\r
210 +** (at your option) any later version.
\r
212 +** $Version $Date $Author $Comment
\r
213 +** 0.0.1 30 June,2009 Lei Chuanhua Initial version
\r
214 +*******************************************************************************/
\r
216 +#ifndef IFXMIPS_PCI_COMMON_H
\r
217 +#define IFXMIPS_PCI_COMMON_H
\r
218 +#include <linux/version.h>
\r
220 + \defgroup IFX_PCI_COM IFX PCI/PCIe common parts for OS integration
\r
221 + \brief PCI/PCIe common parts
\r
225 + \defgroup IFX_PCI_COM_OS OS APIs
\r
226 + \ingroup IFX_PCI_COM
\r
227 + \brief PCI/PCIe bus driver OS interface functions
\r
230 + \file ifxmips_pci_common.h
\r
231 + \ingroup IFX_PCI_COM
\r
232 + \brief PCI/PCIe bus driver common OS header file
\r
234 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
\r
235 +#define IFX_PCI_CONST
\r
237 +#define IFX_PCI_CONST const
\r
239 +#ifdef CONFIG_IFX_PCI
\r
240 +extern int ifx_pci_bios_map_irq(IFX_PCI_CONST struct pci_dev *dev, u8 slot, u8 pin);
\r
241 +extern int ifx_pci_bios_plat_dev_init(struct pci_dev *dev);
\r
242 +#endif /* COFNIG_IFX_PCI */
\r
244 +#ifdef CONFIG_IFX_PCIE
\r
245 +extern int ifx_pcie_bios_map_irq(IFX_PCI_CONST struct pci_dev *dev, u8 slot, u8 pin);
\r
246 +extern int ifx_pcie_bios_plat_dev_init(struct pci_dev *dev);
\r
249 +#endif /* IFXMIPS_PCI_COMMON_H */
\r
252 +++ b/arch/mips/pci/ifxmips_pcie.c
254 +/******************************************************************************
\r
256 +** FILE NAME : ifxmips_pcie.c
\r
257 +** PROJECT : IFX UEIP for VRX200
\r
258 +** MODULES : PCI MSI sub module
\r
260 +** DATE : 02 Mar 2009
\r
261 +** AUTHOR : Lei Chuanhua
\r
262 +** DESCRIPTION : PCIe Root Complex Driver
\r
263 +** COPYRIGHT : Copyright (c) 2009
\r
264 +** Infineon Technologies AG
\r
265 +** Am Campeon 1-12, 85579 Neubiberg, Germany
\r
267 +** This program is free software; you can redistribute it and/or modify
\r
268 +** it under the terms of the GNU General Public License as published by
\r
269 +** the Free Software Foundation; either version 2 of the License, or
\r
270 +** (at your option) any later version.
\r
272 +** $Version $Date $Author $Comment
\r
273 +** 0.0.1 02 Mar,2009 Lei Chuanhua Initial version
\r
274 +*******************************************************************************/
\r
276 + \file ifxmips_pcie.c
\r
277 + \ingroup IFX_PCIE
\r
278 + \brief PCI express bus driver source file
\r
280 +#include <linux/types.h>
\r
281 +#include <linux/pci.h>
\r
282 +#include <linux/kernel.h>
\r
283 +#include <linux/init.h>
\r
284 +#include <linux/delay.h>
\r
285 +#include <linux/mm.h>
\r
286 +#include <asm/paccess.h>
\r
287 +#include <linux/pci.h>
\r
288 +#include <linux/pci_regs.h>
\r
289 +#include <linux/module.h>
\r
291 +#include "ifxmips_pcie.h"
\r
292 +#include "ifxmips_pcie_reg.h"
\r
294 +#define IFX_PCIE_VER_MAJOR 1
\r
295 +#define IFX_PCIE_VER_MID 5
\r
296 +#define IFX_PCIE_VER_MINOR 3
\r
298 +/* Enable 32bit io due to its mem mapped io nature */
\r
299 +#define IFX_PCIE_ERROR_INT
\r
300 +#define CONFIG_IFX_PCIE_1ST_CORE
\r
301 +#define IFX_PCIE_IO_32BIT
\r
303 +#define IFX_PCIE_IR (INT_NUM_IM4_IRL0 + 25)
\r
304 +#define IFX_PCIE_INTA (INT_NUM_IM4_IRL0 + 8)
\r
305 +#define IFX_PCIE_INTB (INT_NUM_IM4_IRL0 + 9)
\r
306 +#define IFX_PCIE_INTC (INT_NUM_IM4_IRL0 + 10)
\r
307 +#define IFX_PCIE_INTD (INT_NUM_IM4_IRL0 + 11)
\r
308 +#define MS(_v, _f) (((_v) & (_f)) >> _f##_S)
\r
309 +#define SM(_v, _f) (((_v) << _f##_S) & (_f))
\r
310 +#define IFX_REG_SET_BIT(_f, _r) \
\r
311 + IFX_REG_W32((IFX_REG_R32((_r)) &~ (_f)) | (_f), (_r))
\r
313 +static DEFINE_SPINLOCK(ifx_pcie_lock);
\r
315 +u32 g_pcie_debug_flag = PCIE_MSG_ANY & (~PCIE_MSG_CFG);
\r
317 +static ifx_pcie_irq_t pcie_irqs[IFX_PCIE_CORE_NR] = {
\r
320 + .irq = IFX_PCIE_IR,
\r
321 + .name = "ifx_pcie_rc0",
\r
326 + .irq_bit = PCIE_IRN_INTA,
\r
327 + .irq = IFX_PCIE_INTA,
\r
330 + .irq_bit = PCIE_IRN_INTB,
\r
331 + .irq = IFX_PCIE_INTB,
\r
334 + .irq_bit = PCIE_IRN_INTC,
\r
335 + .irq = IFX_PCIE_INTC,
\r
338 + .irq_bit = PCIE_IRN_INTD,
\r
339 + .irq = IFX_PCIE_INTD,
\r
344 +#ifdef CONFIG_IFX_PCIE_2ND_CORE
\r
347 + .irq = IFX_PCIE1_IR,
\r
348 + .name = "ifx_pcie_rc1",
\r
353 + .irq_bit = PCIE_IRN_INTA,
\r
354 + .irq = IFX_PCIE1_INTA,
\r
357 + .irq_bit = PCIE_IRN_INTB,
\r
358 + .irq = IFX_PCIE1_INTB,
\r
361 + .irq_bit = PCIE_IRN_INTC,
\r
362 + .irq = IFX_PCIE1_INTC,
\r
365 + .irq_bit = PCIE_IRN_INTD,
\r
366 + .irq = IFX_PCIE1_INTD,
\r
371 +#endif /* CONFIG_IFX_PCIE_2ND_CORE */
\r
375 +ifx_pcie_debug(const char *fmt, ...)
\r
377 + static char buf[256] = {0}; /* XXX */
\r
380 + va_start(ap, fmt);
\r
381 + vsnprintf(buf, sizeof(buf), fmt, ap);
\r
384 + printk("%s", buf);
\r
387 +#ifdef IFX_PCI_PHY_DBG
\r
388 +/* Generate hot reset, XXX must catpure to verify */
\r
389 +static INLINE void
\r
390 +pcie_secondary_bus_reset(int pcie_port)
\r
394 +#define IFX_PCIE_RESET_TIME 20
\r
396 + /* Assert Secondary Bus Reset */
\r
397 + reg = IFX_REG_R32(PCIE_INTRBCTRL(pcie_port));
\r
398 + reg |= PCIE_INTRBCTRL_RST_SECONDARY_BUS;
\r
399 + IFX_REG_W32(reg, PCIE_INTRBCTRL(pcie_port));
\r
401 + /* De-assert Secondary Bus Reset */
\r
402 + reg &= ~PCIE_INTRBCTRL_RST_SECONDARY_BUS;
\r
403 + IFX_REG_W32(reg, PCIE_INTRBCTRL(pcie_port));
\r
405 + /* XXX, wait at least 100 ms, then restore again */
\r
406 + for (i = 0; i < IFX_PCIE_RESET_TIME; i++) {
\r
409 +#undef IFX_PCIE_RESET_TIME
\r
412 +/* Error or L0s to L0 */
\r
413 +static INLINE int
\r
414 +pcie_retrain_link(int pcie_port)
\r
418 +#define IFX_PCIE_RETRAIN_TIME 1000
\r
420 + reg = IFX_REG_R32(PCIE_LCTLSTS(pcie_port));
\r
421 + reg |= PCIE_LCTLSTS_RETRIAN_LINK;
\r
422 + IFX_REG_W32(reg, PCIE_LCTLSTS(pcie_port));
\r
424 + /* Wait for the link to come up */
\r
425 + for (i = 0; i < IFX_PCIE_RETRAIN_TIME; i++) {
\r
426 + if (!(IFX_REG_R32(PCIE_LCTLSTS(pcie_port)) & PCIE_LCTLSTS_RETRAIN_PENDING)) {
\r
431 + if (i >= IFX_PCIE_RETRAIN_TIME) {
\r
432 + IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s retrain timeout\n", __func__);
\r
436 +#undef IFX_PCIE_RETRAIN_TIME
\r
439 +static INLINE void
\r
440 +pcie_disable_scrambling(int pcie_port)
\r
444 + reg = IFX_REG_R32(PCIE_PLCR(pcie_port));
\r
445 + reg |= PCIE_PLCR_SCRAMBLE_DISABLE;
\r
446 + IFX_REG_W32(reg, PCIE_PLCR(pcie_port));
\r
448 +#endif /* IFX_PCI_PHY_DBG */
\r
450 +static INLINE int
\r
451 +pcie_ltssm_enable(int pcie_port)
\r
454 +#define IFX_PCIE_LTSSM_ENABLE_TIMEOUT 10
\r
456 + IFX_REG_W32(PCIE_RC_CCR_LTSSM_ENABLE, PCIE_RC_CCR(pcie_port)); /* Enable LTSSM */
\r
458 + /* Wait for the link to come up */
\r
459 + for (i = 0; i < IFX_PCIE_LTSSM_ENABLE_TIMEOUT; i++) {
\r
460 + if (!(IFX_REG_R32(PCIE_LCTLSTS(pcie_port)) & PCIE_LCTLSTS_RETRAIN_PENDING)) {
\r
465 + if (i >= IFX_PCIE_LTSSM_ENABLE_TIMEOUT) {
\r
466 + IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s link timeout!!!!!\n", __func__);
\r
470 +#undef IFX_PCIE_LTSSM_ENABLE_TIMEOUT
\r
473 +static INLINE void
\r
474 +pcie_ltssm_disable(int pcie_port)
\r
476 + IFX_REG_W32(0, PCIE_RC_CCR(pcie_port)); /* Disable LTSSM */
\r
477 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_RC_CCR 0x%08x\n",
\r
478 + __func__, IFX_REG_R32(PCIE_RC_CCR(pcie_port)));
\r
481 +static INLINE void
\r
482 +pcie_ahb_bus_error_suppress(int pcie_port)
\r
484 + IFX_REG_W32(PCIE_AHB_CTRL_BUS_ERROR_SUPPRESS, PCIE_AHB_CTRL(pcie_port));
\r
487 +static INLINE void
\r
488 +pcie_status_register_clear(int pcie_port)
\r
490 + /* Clear the status register, XXX, seperate function */
\r
491 + IFX_REG_W32(0, PCIE_RC_DR(pcie_port));
\r
492 + IFX_REG_W32(0, PCIE_PCICMDSTS(pcie_port));
\r
493 + IFX_REG_W32(0, PCIE_DCTLSTS(pcie_port));
\r
494 + IFX_REG_W32(0, PCIE_LCTLSTS(pcie_port));
\r
495 + IFX_REG_W32(0, PCIE_SLCTLSTS(pcie_port));
\r
496 + IFX_REG_W32(0, PCIE_RSTS(pcie_port));
\r
497 + IFX_REG_W32(0, PCIE_UES_R(pcie_port));
\r
498 + IFX_REG_W32(0, PCIE_UEMR(pcie_port));
\r
499 + IFX_REG_W32(0, PCIE_UESR(pcie_port));
\r
500 + IFX_REG_W32(0, PCIE_CESR(pcie_port));
\r
501 + IFX_REG_W32(0, PCIE_CEMR(pcie_port));
\r
502 + IFX_REG_W32(0, PCIE_RESR(pcie_port));
\r
503 + IFX_REG_W32(0, PCIE_PVCCRSR(pcie_port));
\r
504 + IFX_REG_W32(0, PCIE_VC0_RSR0(pcie_port));
\r
505 + IFX_REG_W32(0, PCIE_TPFCS(pcie_port));
\r
506 + IFX_REG_W32(0, PCIE_TNPFCS(pcie_port));
\r
507 + IFX_REG_W32(0, PCIE_TCFCS(pcie_port));
\r
508 + IFX_REG_W32(0, PCIE_QSR(pcie_port));
\r
509 + IFX_REG_W32(0, PCIE_IOBLSECS(pcie_port));
\r
512 +static inline int
\r
513 +ifx_pcie_link_up(int pcie_port)
\r
515 + return (IFX_REG_R32(PCIE_PHY_SR(pcie_port)) & PCIE_PHY_SR_PHY_LINK_UP) ? 1 : 0;
\r
518 +#ifdef IFX_PCIE_DBG
\r
520 +pcie_status_registers_dump(int pcie_port)
\r
522 + printk(KERN_INFO "PCIe_PCICMDSTS: 0x%08x\n", IFX_REG_R32(PCIE_PCICMDSTS(pcie_port)));
\r
523 + printk(KERN_INFO "PCIe_RC_DR: 0x%08x\n", IFX_REG_R32(PCIE_RC_DR(pcie_port)));
\r
524 + printk(KERN_INFO "PCIe_DCTLSTS: 0x%08x\n", IFX_REG_R32(PCIE_DCTLSTS(pcie_port)));
\r
525 + printk(KERN_INFO "PCIe_LCTLSTS: 0x%08x\n", IFX_REG_R32(PCIE_LCTLSTS(pcie_port)));
\r
526 + printk(KERN_INFO "PCIe_SLCTLSTS: 0x%08x\n", IFX_REG_R32(PCIE_SLCTLSTS(pcie_port)));
\r
527 + printk(KERN_INFO "PCIe_RSTS: 0x%08x\n", IFX_REG_R32(PCIE_RSTS(pcie_port)));
\r
528 + printk(KERN_INFO "PCIe_UES_R: 0x%08x\n", IFX_REG_R32(PCIE_UES_R(pcie_port)));
\r
529 + printk(KERN_INFO "PCIe_UEMR: 0x%08x\n", IFX_REG_R32(PCIE_UEMR(pcie_port)));
\r
530 + printk(KERN_INFO "PCIe_UESR: 0x%08x\n", IFX_REG_R32(PCIE_UESR(pcie_port)));
\r
531 + printk(KERN_INFO "PCIe_CESR: 0x%08x\n", IFX_REG_R32(PCIE_CESR(pcie_port)));
\r
532 + printk(KERN_INFO "PCIe_CEMR: 0x%08x\n", IFX_REG_R32(PCIE_CEMR(pcie_port)));
\r
533 + printk(KERN_INFO "PCIe_RESR: 0x%08x\n", IFX_REG_R32(PCIE_RESR(pcie_port)));
\r
534 + printk(KERN_INFO "PCIe_ESIR: 0x%08x\n", IFX_REG_R32(PCIE_ESIR(pcie_port)));
\r
535 + printk(KERN_INFO "PCIe_PVCCRSR: 0x%08x\n", IFX_REG_R32(PCIE_PVCCRSR(pcie_port)));
\r
536 + printk(KERN_INFO "PCIe_VC0_RSR0: 0x%08x\n", IFX_REG_R32(PCIE_VC0_RSR0(pcie_port)));
\r
537 + printk(KERN_INFO "PCIe_TPFCS: 0x%08x\n", IFX_REG_R32(PCIE_TPFCS(pcie_port)));
\r
538 + printk(KERN_INFO "PCIe_TNPFCS: 0x%08x\n", IFX_REG_R32(PCIE_TNPFCS(pcie_port)));
\r
539 + printk(KERN_INFO "PCIe_TCFCS: 0x%08x\n", IFX_REG_R32(PCIE_TCFCS(pcie_port)));
\r
540 + printk(KERN_INFO "PCIe_QSR: 0x%08x\n", IFX_REG_R32(PCIE_QSR(pcie_port)));
\r
541 + printk(KERN_INFO "PCIe_VCTAR1: 0x%08x\n", IFX_REG_R32(PCIE_VCTAR1(pcie_port)));
\r
542 + printk(KERN_INFO "PCIe_VCTAR2: 0x%08x\n", IFX_REG_R32(PCIE_VCTAR2(pcie_port)));
\r
543 + printk(KERN_INFO "PCIe_IOBLSECS: 0x%08x\n", IFX_REG_R32(PCIE_IOBLSECS(pcie_port)));
\r
544 + printk(KERN_INFO "PCIe_ALTRT: 0x%08x\n", IFX_REG_R32(PCIE_ALTRT(pcie_port)));
\r
545 + printk(KERN_INFO "PCIe_SNR: 0x%08x\n", IFX_REG_R32(PCIE_SNR(pcie_port)));
\r
546 + printk(KERN_INFO "PCIe_DBR0: 0x%08x\n", IFX_REG_R32(PCIE_DBR0(pcie_port)));
\r
547 + printk(KERN_INFO "PCIe_DBR1: 0x%08x\n", IFX_REG_R32(PCIE_DBR1(pcie_port)));
\r
551 +pcie_post_dump(int pcie_port)
\r
553 + printk(KERN_INFO "PCIe_PCICMDSTS: 0x%08x\n", IFX_REG_R32(PCIE_PCICMDSTS(pcie_port)));
\r
554 + printk(KERN_INFO "PCIe_MBML: 0x%08x\n", IFX_REG_R32(PCIE_MBML(pcie_port)));
\r
555 + printk(KERN_INFO "PCIe_PBML: 0x%08x\n", IFX_REG_R32(PCIE_PMBL(pcie_port)));
\r
556 + printk(KERN_INFO "PCIe_IOBLSECS: 0x%08x\n", IFX_REG_R32(PCIE_IOBLSECS(pcie_port)));
\r
557 + printk(KERN_INFO "PCIe_IO_BANDL: 0x%08x\n", IFX_REG_R32(PCIE_IO_BANDL(pcie_port)));
\r
558 + printk(KERN_INFO "PCIe_INTRBCTRL: 0x%08x\n", IFX_REG_R32(PCIE_INTRBCTRL(pcie_port)));
\r
559 + printk(KERN_INFO "Power State: D%1d\n", IFX_REG_R32(PCIE_PM_CSR(pcie_port)) & PCIE_PM_CSR_POWER_STATE);
\r
560 + printk(KERN_INFO "Negotiated Link Width: %d\n", MS(IFX_REG_R32(PCIE_LCTLSTS(pcie_port)), PCIE_LCTLSTS_NEGOTIATED_LINK_WIDTH));
\r
561 + printk(KERN_INFO "Number of VCs: %d\n", IFX_REG_R32(PCIE_PVC1(pcie_port)) & PCIE_PVC1_EXT_VC_CNT);
\r
562 + printk(KERN_INFO "Low-priority VCs: %d\n", MS(IFX_REG_R32(PCIE_PVC1(pcie_port)), PCIE_PVC1_LOW_PRI_EXT_VC_CNT));
\r
563 + printk(KERN_INFO "VC Arbitration: 0x%08x\n", IFX_REG_R32(PCIE_PVC2(pcie_port)) & PCIE_PVC2_VC_ARB_WRR);
\r
564 + printk(KERN_INFO "Port Arbitration: 0x%08x\n", IFX_REG_R32(PCIE_VC0_RC(pcie_port)) & PCIE_VC0_RC_PORT_ARB);
\r
566 + if (ifx_pcie_link_up(pcie_port)) {
\r
567 + printk(KERN_INFO "PCIe PHY Link is UP\n");
\r
570 + printk(KERN_INFO "PCIe PHY Link is DOWN!\n");
\r
572 + if ((IFX_REG_R32(PCIE_RC_DR(pcie_port)) & PCIE_RC_DR_DLL_UP)) {
\r
573 + printk(KERN_INFO "PCIe DLL is UP\n");
\r
576 + printk(KERN_INFO "PCIe DLL is DOWN!\n");
\r
579 + if ((IFX_REG_R32(PCIE_LCTLSTS(pcie_port)) & PCIE_LCTLSTS_DLL_ACTIVE)) {
\r
580 + printk(KERN_INFO "PCIE_LCTLSTS in DL_Active state!\n");
\r
583 + printk(KERN_INFO "PCIE_LCTLSTS NOT in DL_Active state!\n");
\r
586 +#endif /* IFX_PCIE_DBG */
\r
588 +/* XXX, this function is not needed in fact */
\r
589 +static INLINE void
\r
590 +pcie_mem_io_setup(int pcie_port)
\r
594 + * BAR[0:1] readonly register
\r
595 + * RC contains only minimal BARs for packets mapped to this device
\r
596 + * Mem/IO filters defines a range of memory occupied by memory mapped IO devices that
\r
597 + * reside on the downstream side fo the bridge.
\r
599 + reg = SM((PCIE_MEM_PHY_PORT_TO_END(pcie_port) >> 20), PCIE_MBML_MEM_LIMIT_ADDR)
\r
600 + | SM((PCIE_MEM_PHY_PORT_TO_BASE(pcie_port) >> 20), PCIE_MBML_MEM_BASE_ADDR);
\r
602 + IFX_REG_W32(reg, PCIE_MBML(pcie_port));
\r
604 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_MBML: 0x%08x\n",
\r
605 + __func__, IFX_REG_R32(PCIE_MBML(pcie_port)));
\r
607 +#ifdef IFX_PCIE_PREFETCH_MEM_64BIT
\r
608 + reg = SM((PCIE_MEM_PHY_PORT_TO_END(pcie_port) >> 20), PCIE_PMBL_END_ADDR)
\r
609 + | SM((PCIE_MEM_PHY_PORT_TO_BASE(pcie_port) >> 20), PCIE_PMBL_UPPER_12BIT)
\r
610 + | PCIE_PMBL_64BIT_ADDR;
\r
611 + IFX_REG_W32(reg, PCIE_PMBL(pcie_port));
\r
613 + /* Must configure upper 32bit */
\r
614 + IFX_REG_W32(0, PCIE_PMBU32(pcie_port));
\r
615 + IFX_REG_W32(0, PCIE_PMLU32(pcie_port));
\r
617 + /* PCIe_PBML, same as MBML */
\r
618 + IFX_REG_W32(IFX_REG_R32(PCIE_MBML(pcie_port)), PCIE_PMBL(pcie_port));
\r
620 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_PMBL: 0x%08x\n",
\r
621 + __func__, IFX_REG_R32(PCIE_PMBL(pcie_port)));
\r
623 + /* IO Address Range */
\r
624 + reg = SM((PCIE_IO_PHY_PORT_TO_END(pcie_port) >> 12), PCIE_IOBLSECS_IO_LIMIT_ADDR)
\r
625 + | SM((PCIE_IO_PHY_PORT_TO_BASE(pcie_port) >> 12), PCIE_IOBLSECS_IO_BASE_ADDR);
\r
626 +#ifdef IFX_PCIE_IO_32BIT
\r
627 + reg |= PCIE_IOBLSECS_32BIT_IO_ADDR;
\r
628 +#endif /* IFX_PCIE_IO_32BIT */
\r
629 + IFX_REG_W32(reg, PCIE_IOBLSECS(pcie_port));
\r
631 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_IOBLSECS: 0x%08x\n",
\r
632 + __func__, IFX_REG_R32(PCIE_IOBLSECS(pcie_port)));
\r
633 +#ifdef IFX_PCIE_IO_32BIT
\r
634 + reg = SM((PCIE_IO_PHY_PORT_TO_END(pcie_port) >> 16), PCIE_IO_BANDL_UPPER_16BIT_IO_LIMIT)
\r
635 + | SM((PCIE_IO_PHY_PORT_TO_BASE(pcie_port) >> 16), PCIE_IO_BANDL_UPPER_16BIT_IO_BASE);
\r
636 + IFX_REG_W32(reg, PCIE_IO_BANDL(pcie_port));
\r
638 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_IO_BANDL: 0x%08x\n",
\r
639 + __func__, IFX_REG_R32(PCIE_IO_BANDL(pcie_port)));
\r
640 +#endif /* IFX_PCIE_IO_32BIT */
\r
643 +static INLINE void
\r
644 +pcie_msi_setup(int pcie_port)
\r
648 + /* XXX, MSI stuff should only apply to EP */
\r
649 + /* MSI Capability: Only enable 32-bit addresses */
\r
650 + reg = IFX_REG_R32(PCIE_MCAPR(pcie_port));
\r
651 + reg &= ~PCIE_MCAPR_ADDR64_CAP;
\r
653 + reg |= PCIE_MCAPR_MSI_ENABLE;
\r
655 + /* Disable multiple message */
\r
656 + reg &= ~(PCIE_MCAPR_MULTI_MSG_CAP | PCIE_MCAPR_MULTI_MSG_ENABLE);
\r
657 + IFX_REG_W32(reg, PCIE_MCAPR(pcie_port));
\r
658 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_MCAPR: 0x%08x\n",
\r
659 + __func__, IFX_REG_R32(PCIE_MCAPR(pcie_port)));
\r
662 +static INLINE void
\r
663 +pcie_pm_setup(int pcie_port)
\r
667 + /* Enable PME, Soft reset enabled */
\r
668 + reg = IFX_REG_R32(PCIE_PM_CSR(pcie_port));
\r
669 + reg |= PCIE_PM_CSR_PME_ENABLE | PCIE_PM_CSR_SW_RST;
\r
670 + IFX_REG_W32(reg, PCIE_PM_CSR(pcie_port));
\r
671 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_PM_CSR: 0x%08x\n",
\r
672 + __func__, IFX_REG_R32(PCIE_PM_CSR(pcie_port)));
\r
675 +static INLINE void
\r
676 +pcie_bus_setup(int pcie_port)
\r
680 + reg = SM(0, PCIE_BNR_PRIMARY_BUS_NUM) | SM(1, PCIE_PNR_SECONDARY_BUS_NUM) | SM(0xFF, PCIE_PNR_SUB_BUS_NUM);
\r
681 + IFX_REG_W32(reg, PCIE_BNR(pcie_port));
\r
682 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_BNR: 0x%08x\n",
\r
683 + __func__, IFX_REG_R32(PCIE_BNR(pcie_port)));
\r
686 +static INLINE void
\r
687 +pcie_device_setup(int pcie_port)
\r
691 + /* Device capability register, set up Maximum payload size */
\r
692 + reg = IFX_REG_R32(PCIE_DCAP(pcie_port));
\r
693 + reg |= PCIE_DCAP_ROLE_BASE_ERR_REPORT;
\r
694 + reg |= SM(PCIE_MAX_PAYLOAD_128, PCIE_DCAP_MAX_PAYLOAD_SIZE);
\r
696 + /* Only available for EP */
\r
697 + reg &= ~(PCIE_DCAP_EP_L0S_LATENCY | PCIE_DCAP_EP_L1_LATENCY);
\r
698 + IFX_REG_W32(reg, PCIE_DCAP(pcie_port));
\r
699 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_DCAP: 0x%08x\n",
\r
700 + __func__, IFX_REG_R32(PCIE_DCAP(pcie_port)));
\r
702 + /* Device control and status register */
\r
703 + /* Set Maximum Read Request size for the device as a Requestor */
\r
704 + reg = IFX_REG_R32(PCIE_DCTLSTS(pcie_port));
\r
707 + * Request size can be larger than the MPS used, but the completions returned
\r
708 + * for the read will be bounded by the MPS size.
\r
709 + * In our system, Max request size depends on AHB burst size. It is 64 bytes.
\r
710 + * but we set it as 128 as minimum one.
\r
712 + reg |= SM(PCIE_MAX_PAYLOAD_128, PCIE_DCTLSTS_MAX_READ_SIZE)
\r
713 + | SM(PCIE_MAX_PAYLOAD_128, PCIE_DCTLSTS_MAX_PAYLOAD_SIZE);
\r
715 + /* Enable relaxed ordering, no snoop, and all kinds of errors */
\r
716 + reg |= PCIE_DCTLSTS_RELAXED_ORDERING_EN | PCIE_DCTLSTS_ERR_EN | PCIE_DCTLSTS_NO_SNOOP_EN;
\r
718 + IFX_REG_W32(reg, PCIE_DCTLSTS(pcie_port));
\r
719 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_DCTLSTS: 0x%08x\n",
\r
720 + __func__, IFX_REG_R32(PCIE_DCTLSTS(pcie_port)));
\r
723 +static INLINE void
\r
724 +pcie_link_setup(int pcie_port)
\r
729 + * XXX, Link capability register, bit 18 for EP CLKREQ# dynamic clock management for L1, L2/3 CPM
\r
730 + * L0s is reported during link training via TS1 order set by N_FTS
\r
732 + reg = IFX_REG_R32(PCIE_LCAP(pcie_port));
\r
733 + reg &= ~PCIE_LCAP_L0S_EIXT_LATENCY;
\r
734 + reg |= SM(3, PCIE_LCAP_L0S_EIXT_LATENCY);
\r
735 + IFX_REG_W32(reg, PCIE_LCAP(pcie_port));
\r
736 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_LCAP: 0x%08x\n",
\r
737 + __func__, IFX_REG_R32(PCIE_LCAP(pcie_port)));
\r
739 + /* Link control and status register */
\r
740 + reg = IFX_REG_R32(PCIE_LCTLSTS(pcie_port));
\r
742 + /* Link Enable, ASPM enabled */
\r
743 + reg &= ~PCIE_LCTLSTS_LINK_DISABLE;
\r
745 +#ifdef CONFIG_PCIEASPM
\r
747 + * We use the same physical reference clock that the platform provides on the connector
\r
748 + * It paved the way for ASPM to calculate the new exit Latency
\r
750 + reg |= PCIE_LCTLSTS_SLOT_CLK_CFG;
\r
751 + reg |= PCIE_LCTLSTS_COM_CLK_CFG;
\r
753 + * We should disable ASPM by default except that we have dedicated power management support
\r
754 + * Enable ASPM will cause the system hangup/instability, performance degration
\r
756 + reg |= PCIE_LCTLSTS_ASPM_ENABLE;
\r
758 + reg &= ~PCIE_LCTLSTS_ASPM_ENABLE;
\r
759 +#endif /* CONFIG_PCIEASPM */
\r
762 + * The maximum size of any completion with data packet is bounded by the MPS setting
\r
763 + * in device control register
\r
766 + /* RCB may cause multiple split transactions, two options available, we use 64 byte RCB */
\r
767 + reg &= ~ PCIE_LCTLSTS_RCB128;
\r
769 + IFX_REG_W32(reg, PCIE_LCTLSTS(pcie_port));
\r
770 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_LCTLSTS: 0x%08x\n",
\r
771 + __func__, IFX_REG_R32(PCIE_LCTLSTS(pcie_port)));
\r
774 +static INLINE void
\r
775 +pcie_error_setup(int pcie_port)
\r
780 + * Forward ERR_COR, ERR_NONFATAL, ERR_FATAL to the backbone
\r
781 + * Poisoned write TLPs and completions indicating poisoned TLPs will set the PCIe_PCICMDSTS.MDPE
\r
783 + reg = IFX_REG_R32(PCIE_INTRBCTRL(pcie_port));
\r
784 + reg |= PCIE_INTRBCTRL_SERR_ENABLE | PCIE_INTRBCTRL_PARITY_ERR_RESP_ENABLE;
\r
786 + IFX_REG_W32(reg, PCIE_INTRBCTRL(pcie_port));
\r
787 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_INTRBCTRL: 0x%08x\n",
\r
788 + __func__, IFX_REG_R32(PCIE_INTRBCTRL(pcie_port)));
\r
790 + /* Uncorrectable Error Mask Register, Unmask <enable> all bits in PCIE_UESR */
\r
791 + reg = IFX_REG_R32(PCIE_UEMR(pcie_port));
\r
792 + reg &= ~PCIE_ALL_UNCORRECTABLE_ERR;
\r
793 + IFX_REG_W32(reg, PCIE_UEMR(pcie_port));
\r
794 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_UEMR: 0x%08x\n",
\r
795 + __func__, IFX_REG_R32(PCIE_UEMR(pcie_port)));
\r
797 + /* Uncorrectable Error Severity Register, ALL errors are FATAL */
\r
798 + IFX_REG_W32(PCIE_ALL_UNCORRECTABLE_ERR, PCIE_UESR(pcie_port));
\r
799 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_UESR: 0x%08x\n",
\r
800 + __func__, IFX_REG_R32(PCIE_UESR(pcie_port)));
\r
802 + /* Correctable Error Mask Register, unmask <enable> all bits */
\r
803 + reg = IFX_REG_R32(PCIE_CEMR(pcie_port));
\r
804 + reg &= ~PCIE_CORRECTABLE_ERR;
\r
805 + IFX_REG_W32(reg, PCIE_CEMR(pcie_port));
\r
806 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_CEMR: 0x%08x\n",
\r
807 + __func__, IFX_REG_R32(PCIE_CEMR(pcie_port)));
\r
809 + /* Advanced Error Capabilities and Control Registr */
\r
810 + reg = IFX_REG_R32(PCIE_AECCR(pcie_port));
\r
811 + reg |= PCIE_AECCR_ECRC_CHECK_EN | PCIE_AECCR_ECRC_GEN_EN;
\r
812 + IFX_REG_W32(reg, PCIE_AECCR(pcie_port));
\r
813 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_AECCR: 0x%08x\n",
\r
814 + __func__, IFX_REG_R32(PCIE_AECCR(pcie_port)));
\r
816 + /* Root Error Command Register, Report all types of errors */
\r
817 + reg = IFX_REG_R32(PCIE_RECR(pcie_port));
\r
818 + reg |= PCIE_RECR_ERR_REPORT_EN;
\r
819 + IFX_REG_W32(reg, PCIE_RECR(pcie_port));
\r
820 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_RECR: 0x%08x\n",
\r
821 + __func__, IFX_REG_R32(PCIE_RECR(pcie_port)));
\r
823 + /* Clear the Root status register */
\r
824 + reg = IFX_REG_R32(PCIE_RESR(pcie_port));
\r
825 + IFX_REG_W32(reg, PCIE_RESR(pcie_port));
\r
828 +static INLINE void
\r
829 +pcie_root_setup(int pcie_port)
\r
833 + /* Root control and capabilities register */
\r
834 + reg = IFX_REG_R32(PCIE_RCTLCAP(pcie_port));
\r
835 + reg |= PCIE_RCTLCAP_SERR_ENABLE | PCIE_RCTLCAP_PME_INT_EN;
\r
836 + IFX_REG_W32(reg, PCIE_RCTLCAP(pcie_port));
\r
837 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_RCTLCAP: 0x%08x\n",
\r
838 + __func__, IFX_REG_R32(PCIE_RCTLCAP(pcie_port)));
\r
841 +static INLINE void
\r
842 +pcie_vc_setup(int pcie_port)
\r
846 + /* Port VC Capability Register 2 */
\r
847 + reg = IFX_REG_R32(PCIE_PVC2(pcie_port));
\r
848 + reg &= ~PCIE_PVC2_VC_ARB_WRR;
\r
849 + reg |= PCIE_PVC2_VC_ARB_16P_FIXED_WRR;
\r
850 + IFX_REG_W32(reg, PCIE_PVC2(pcie_port));
\r
851 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_PVC2: 0x%08x\n",
\r
852 + __func__, IFX_REG_R32(PCIE_PVC2(pcie_port)));
\r
854 + /* VC0 Resource Capability Register */
\r
855 + reg = IFX_REG_R32(PCIE_VC0_RC(pcie_port));
\r
856 + reg &= ~PCIE_VC0_RC_REJECT_SNOOP;
\r
857 + IFX_REG_W32(reg, PCIE_VC0_RC(pcie_port));
\r
858 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_VC0_RC: 0x%08x\n",
\r
859 + __func__, IFX_REG_R32(PCIE_VC0_RC(pcie_port)));
\r
862 +static INLINE void
\r
863 +pcie_port_logic_setup(int pcie_port)
\r
867 + /* FTS number, default 12, increase to 63, may increase time from/to L0s to L0 */
\r
868 + reg = IFX_REG_R32(PCIE_AFR(pcie_port));
\r
869 + reg &= ~(PCIE_AFR_FTS_NUM | PCIE_AFR_COM_FTS_NUM);
\r
870 + reg |= SM(PCIE_AFR_FTS_NUM_DEFAULT, PCIE_AFR_FTS_NUM)
\r
871 + | SM(PCIE_AFR_FTS_NUM_DEFAULT, PCIE_AFR_COM_FTS_NUM);
\r
872 + /* L0s and L1 entry latency */
\r
873 + reg &= ~(PCIE_AFR_L0S_ENTRY_LATENCY | PCIE_AFR_L1_ENTRY_LATENCY);
\r
874 + reg |= SM(PCIE_AFR_L0S_ENTRY_LATENCY_DEFAULT, PCIE_AFR_L0S_ENTRY_LATENCY)
\r
875 + | SM(PCIE_AFR_L1_ENTRY_LATENCY_DEFAULT, PCIE_AFR_L1_ENTRY_LATENCY);
\r
876 + IFX_REG_W32(reg, PCIE_AFR(pcie_port));
\r
878 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_AFR: 0x%08x\n",
\r
879 + __func__, IFX_REG_R32(PCIE_AFR(pcie_port)));
\r
881 + /* Port Link Control Register */
\r
882 + reg = IFX_REG_R32(PCIE_PLCR(pcie_port));
\r
883 + reg |= PCIE_PLCR_DLL_LINK_EN; /* Enable the DLL link */
\r
884 + IFX_REG_W32(reg, PCIE_PLCR(pcie_port));
\r
885 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_PLCR: 0x%08x\n",
\r
886 + __func__, IFX_REG_R32(PCIE_PLCR(pcie_port)));
\r
888 + /* Lane Skew Register */
\r
889 + reg = IFX_REG_R32(PCIE_LSR(pcie_port));
\r
890 + /* Enable ACK/NACK and FC */
\r
891 + reg &= ~(PCIE_LSR_ACKNAK_DISABLE | PCIE_LSR_FC_DISABLE);
\r
892 + IFX_REG_W32(reg, PCIE_LSR(pcie_port));
\r
893 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_LSR: 0x%08x\n",
\r
894 + __func__, IFX_REG_R32(PCIE_LSR(pcie_port)));
\r
896 + /* Symbol Timer Register and Filter Mask Register 1 */
\r
897 + reg = IFX_REG_R32(PCIE_STRFMR(pcie_port));
\r
899 + /* Default SKP interval is very accurate already, 5us */
\r
900 + /* Enable IO/CFG transaction */
\r
901 + reg |= PCIE_STRFMR_RX_CFG_TRANS_ENABLE | PCIE_STRFMR_RX_IO_TRANS_ENABLE;
\r
902 + /* Disable FC WDT */
\r
903 + reg &= ~PCIE_STRFMR_FC_WDT_DISABLE;
\r
904 + IFX_REG_W32(reg, PCIE_STRFMR(pcie_port));
\r
905 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_STRFMR: 0x%08x\n",
\r
906 + __func__, IFX_REG_R32(PCIE_STRFMR(pcie_port)));
\r
908 + /* Filter Masker Register 2 */
\r
909 + reg = IFX_REG_R32(PCIE_FMR2(pcie_port));
\r
910 + reg |= PCIE_FMR2_VENDOR_MSG1_PASSED_TO_TRGT1 | PCIE_FMR2_VENDOR_MSG0_PASSED_TO_TRGT1;
\r
911 + IFX_REG_W32(reg, PCIE_FMR2(pcie_port));
\r
912 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_FMR2: 0x%08x\n",
\r
913 + __func__, IFX_REG_R32(PCIE_FMR2(pcie_port)));
\r
915 + /* VC0 Completion Receive Queue Control Register */
\r
916 + reg = IFX_REG_R32(PCIE_VC0_CRQCR(pcie_port));
\r
917 + reg &= ~PCIE_VC0_CRQCR_CPL_TLP_QUEUE_MODE;
\r
918 + reg |= SM(PCIE_VC0_TLP_QUEUE_MODE_BYPASS, PCIE_VC0_CRQCR_CPL_TLP_QUEUE_MODE);
\r
919 + IFX_REG_W32(reg, PCIE_VC0_CRQCR(pcie_port));
\r
920 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_VC0_CRQCR: 0x%08x\n",
\r
921 + __func__, IFX_REG_R32(PCIE_VC0_CRQCR(pcie_port)));
\r
924 +static INLINE void
\r
925 +pcie_rc_cfg_reg_setup(int pcie_port)
\r
927 + pcie_ltssm_disable(pcie_port);
\r
928 + pcie_mem_io_setup(pcie_port);
\r
929 + pcie_msi_setup(pcie_port);
\r
930 + pcie_pm_setup(pcie_port);
\r
931 + pcie_bus_setup(pcie_port);
\r
932 + pcie_device_setup(pcie_port);
\r
933 + pcie_link_setup(pcie_port);
\r
934 + pcie_error_setup(pcie_port);
\r
935 + pcie_root_setup(pcie_port);
\r
936 + pcie_vc_setup(pcie_port);
\r
937 + pcie_port_logic_setup(pcie_port);
\r
941 +ifx_pcie_wait_phy_link_up(int pcie_port)
\r
943 +#define IFX_PCIE_PHY_LINK_UP_TIMEOUT 1000 /* XXX, tunable */
\r
946 + /* Wait for PHY link is up */
\r
947 + for (i = 0; i < IFX_PCIE_PHY_LINK_UP_TIMEOUT; i++) {
\r
948 + if (ifx_pcie_link_up(pcie_port)) {
\r
953 + if (i >= IFX_PCIE_PHY_LINK_UP_TIMEOUT) {
\r
954 + printk(KERN_ERR "%s timeout\n", __func__);
\r
958 + /* Check data link up or not */
\r
959 + if (!(IFX_REG_R32(PCIE_RC_DR(pcie_port)) & PCIE_RC_DR_DLL_UP)) {
\r
960 + printk(KERN_ERR "%s DLL link is still down\n", __func__);
\r
964 + /* Check Data link active or not */
\r
965 + if (!(IFX_REG_R32(PCIE_LCTLSTS(pcie_port)) & PCIE_LCTLSTS_DLL_ACTIVE)) {
\r
966 + printk(KERN_ERR "%s DLL is not active\n", __func__);
\r
970 +#undef IFX_PCIE_PHY_LINK_UP_TIMEOUT
\r
974 +pcie_app_loigc_setup(int pcie_port)
\r
976 +#ifdef IFX_PCIE_PHY_DBG
\r
977 + pcie_disable_scrambling(pcie_port);
\r
978 +#endif /* IFX_PCIE_PHY_DBG */
\r
979 + pcie_ahb_bus_error_suppress(pcie_port);
\r
981 + /* Pull PCIe EP out of reset */
\r
982 + pcie_device_rst_deassert(pcie_port);
\r
984 + /* Start LTSSM training between RC and EP */
\r
985 + pcie_ltssm_enable(pcie_port);
\r
987 + /* Check PHY status after enabling LTSSM */
\r
988 + if (ifx_pcie_wait_phy_link_up(pcie_port) != 0) {
\r
995 + * Must be done after ltssm due to based on negotiated link
\r
996 + * width and payload size
\r
997 + * Update the Replay Time Limit. Empirically, some PCIe
\r
998 + * devices take a little longer to respond than expected under
\r
999 + * load. As a workaround for this we configure the Replay Time
\r
1000 + * Limit to the value expected for a 512 byte MPS instead of
\r
1001 + * our actual 128 byte MPS. The numbers below are directly
\r
1002 + * from the PCIe spec table 3-4/5.
\r
1004 +static INLINE void
\r
1005 +pcie_replay_time_update(int pcie_port)
\r
1011 + reg = IFX_REG_R32(PCIE_LCTLSTS(pcie_port));
\r
1013 + nlw = MS(reg, PCIE_LCTLSTS_NEGOTIATED_LINK_WIDTH);
\r
1015 + case PCIE_MAX_LENGTH_WIDTH_X1:
\r
1018 + case PCIE_MAX_LENGTH_WIDTH_X2:
\r
1021 + case PCIE_MAX_LENGTH_WIDTH_X4:
\r
1024 + case PCIE_MAX_LENGTH_WIDTH_X8:
\r
1031 + reg = IFX_REG_R32(PCIE_ALTRT(pcie_port));
\r
1032 + reg &= ~PCIE_ALTRT_REPLAY_TIME_LIMIT;
\r
1033 + reg |= SM(rtl, PCIE_ALTRT_REPLAY_TIME_LIMIT);
\r
1034 + IFX_REG_W32(reg, PCIE_ALTRT(pcie_port));
\r
1036 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_ALTRT 0x%08x\n",
\r
1037 + __func__, IFX_REG_R32(PCIE_ALTRT(pcie_port)));
\r
1041 + * Table 359 Enhanced Configuration Address Mapping1)
\r
1042 + * 1) This table is defined in Table 7-1, page 341, PCI Express Base Specification v1.1
\r
1043 + * Memory Address PCI Express Configuration Space
\r
1044 + * A[(20+n-1):20] Bus Number 1 < n < 8
\r
1045 + * A[19:15] Device Number
\r
1046 + * A[14:12] Function Number
\r
1047 + * A[11:8] Extended Register Number
\r
1048 + * A[7:2] Register Number
\r
1049 + * A[1:0] Along with size of the access, used to generate Byte Enables
\r
1050 + * For VR9, only the address bits [22:0] are mapped to the configuration space:
\r
1051 + * . Address bits [22:20] select the target bus (1-of-8)1)
\r
1052 + * . Address bits [19:15] select the target device (1-of-32) on the bus
\r
1053 + * . Address bits [14:12] select the target function (1-of-8) within the device.
\r
1054 + * . Address bits [11:2] selects the target dword (1-of-1024) within the selected function.s configuration space
\r
1055 + * . Address bits [1:0] define the start byte location within the selected dword.
\r
1057 +static inline u32
\r
1058 +pcie_bus_addr(u8 bus_num, u16 devfn, int where)
\r
1065 + addr = ((PCI_SLOT(devfn) & 0x1F) << 15) | ((PCI_FUNC(devfn) & 0x7) << 12) | ((where & 0xFFF)& ~3);
\r
1069 + /* type 1, only support 8 buses */
\r
1070 + addr = ((bus & 0x7) << 20) | ((PCI_SLOT(devfn) & 0x1F) << 15) |
\r
1071 + ((PCI_FUNC(devfn) & 0x7) << 12) | ((where & 0xFFF) & ~3);
\r
1073 + IFX_PCIE_PRINT(PCIE_MSG_CFG, "%s: bus addr : %02x:%02x.%01x/%02x, addr=%08x\n",
\r
1074 + __func__, bus_num, PCI_SLOT(devfn), PCI_FUNC(devfn), where, addr);
\r
1079 +pcie_valid_config(int pcie_port, int bus, int dev)
\r
1082 + if ((bus == 0) && (dev == 0)) {
\r
1086 + /* No physical link */
\r
1087 + if (!ifx_pcie_link_up(pcie_port)) {
\r
1091 + /* Bus zero only has RC itself
\r
1092 + * XXX, check if EP will be integrated
\r
1094 + if ((bus == 0) && (dev != 0)) {
\r
1098 + /* Maximum 8 buses supported for VRX */
\r
1104 + * PCIe is PtP link, one bus only supports only one device
\r
1105 + * except bus zero and PCIe switch which is virtual bus device
\r
1106 + * The following two conditions really depends on the system design
\r
1107 + * and attached the device.
\r
1108 + * XXX, how about more new switch
\r
1110 + if ((bus == 1) && (dev != 0)) {
\r
1114 + if ((bus >= 3) && (dev != 0)) {
\r
1120 +static INLINE u32
\r
1121 +ifx_pcie_cfg_rd(int pcie_port, u32 reg)
\r
1123 + return IFX_REG_R32((volatile u32 *)(PCIE_CFG_PORT_TO_BASE(pcie_port) + reg));
\r
1126 +static INLINE void
\r
1127 +ifx_pcie_cfg_wr(int pcie_port, unsigned int reg, u32 val)
\r
1129 + IFX_REG_W32( val, (volatile u32 *)(PCIE_CFG_PORT_TO_BASE(pcie_port) + reg));
\r
1132 +static INLINE u32
\r
1133 +ifx_pcie_rc_cfg_rd(int pcie_port, u32 reg)
\r
1135 + return IFX_REG_R32((volatile u32 *)(PCIE_RC_PORT_TO_BASE(pcie_port) + reg));
\r
1138 +static INLINE void
\r
1139 +ifx_pcie_rc_cfg_wr(int pcie_port, unsigned int reg, u32 val)
\r
1141 + IFX_REG_W32(val, (volatile u32 *)(PCIE_RC_PORT_TO_BASE(pcie_port) + reg));
\r
1145 +ifx_pcie_bus_enum_read_hack(int where, u32 value)
\r
1147 + u32 tvalue = value;
\r
1149 + if (where == PCI_PRIMARY_BUS) {
\r
1150 + u8 primary, secondary, subordinate;
\r
1152 + primary = tvalue & 0xFF;
\r
1153 + secondary = (tvalue >> 8) & 0xFF;
\r
1154 + subordinate = (tvalue >> 16) & 0xFF;
\r
1155 + primary += pcibios_1st_host_bus_nr();
\r
1156 + secondary += pcibios_1st_host_bus_nr();
\r
1157 + subordinate += pcibios_1st_host_bus_nr();
\r
1158 + tvalue = (tvalue & 0xFF000000) | (u32)primary | (u32)(secondary << 8) | (u32)(subordinate << 16);
\r
1164 +ifx_pcie_bus_enum_write_hack(int where, u32 value)
\r
1166 + u32 tvalue = value;
\r
1168 + if (where == PCI_PRIMARY_BUS) {
\r
1169 + u8 primary, secondary, subordinate;
\r
1171 + primary = tvalue & 0xFF;
\r
1172 + secondary = (tvalue >> 8) & 0xFF;
\r
1173 + subordinate = (tvalue >> 16) & 0xFF;
\r
1174 + if (primary > 0 && primary != 0xFF) {
\r
1175 + primary -= pcibios_1st_host_bus_nr();
\r
1178 + if (secondary > 0 && secondary != 0xFF) {
\r
1179 + secondary -= pcibios_1st_host_bus_nr();
\r
1181 + if (subordinate > 0 && subordinate != 0xFF) {
\r
1182 + subordinate -= pcibios_1st_host_bus_nr();
\r
1184 + tvalue = (tvalue & 0xFF000000) | (u32)primary | (u32)(secondary << 8) | (u32)(subordinate << 16);
\r
1186 + else if (where == PCI_SUBORDINATE_BUS) {
\r
1187 + u8 subordinate = tvalue & 0xFF;
\r
1189 + subordinate = subordinate > 0 ? subordinate - pcibios_1st_host_bus_nr() : 0;
\r
1190 + tvalue = subordinate;
\r
1196 + * \fn static int ifx_pcie_read_config(struct pci_bus *bus, u32 devfn,
\r
1197 + * int where, int size, u32 *value)
\r
1198 + * \brief Read a value from configuration space
\r
1200 + * \param[in] bus Pointer to pci bus
\r
1201 + * \param[in] devfn PCI device function number
\r
1202 + * \param[in] where PCI register number
\r
1203 + * \param[in] size Register read size
\r
1204 + * \param[out] value Pointer to return value
\r
1205 + * \return PCIBIOS_BAD_REGISTER_NUMBER Invalid register number
\r
1206 + * \return PCIBIOS_FUNC_NOT_SUPPORTED PCI function not supported
\r
1207 + * \return PCIBIOS_DEVICE_NOT_FOUND PCI device not found
\r
1208 + * \return PCIBIOS_SUCCESSFUL OK
\r
1209 + * \ingroup IFX_PCIE_OS
\r
1212 +ifx_pcie_read_config(struct pci_bus *bus, u32 devfn,
\r
1213 + int where, int size, u32 *value)
\r
1216 + int bus_number = bus->number;
\r
1217 + static const u32 mask[8] = {0, 0xff, 0xffff, 0, 0xffffffff, 0, 0, 0};
\r
1218 + int ret = PCIBIOS_SUCCESSFUL;
\r
1219 + struct ifx_pci_controller *ctrl = bus->sysdata;
\r
1220 + int pcie_port = ctrl->port;
\r
1222 + if (unlikely(size != 1 && size != 2 && size != 4)){
\r
1223 + ret = PCIBIOS_BAD_REGISTER_NUMBER;
\r
1227 + /* Make sure the address is aligned to natural boundary */
\r
1228 + if (unlikely(((size - 1) & where))) {
\r
1229 + ret = PCIBIOS_BAD_REGISTER_NUMBER;
\r
1234 + * If we are second controller, we have to cheat OS so that it assume
\r
1235 + * its bus number starts from 0 in host controller
\r
1237 + bus_number = ifx_pcie_bus_nr_deduct(bus_number, pcie_port);
\r
1240 + * We need to force the bus number to be zero on the root
\r
1241 + * bus. Linux numbers the 2nd root bus to start after all
\r
1242 + * busses on root 0.
\r
1244 + if (bus->parent == NULL) {
\r
1245 + bus_number = 0;
\r
1249 + * PCIe only has a single device connected to it. It is
\r
1250 + * always device ID 0. Don't bother doing reads for other
\r
1251 + * device IDs on the first segment.
\r
1253 + if ((bus_number == 0) && (PCI_SLOT(devfn) != 0)) {
\r
1254 + ret = PCIBIOS_FUNC_NOT_SUPPORTED;
\r
1258 + if (pcie_valid_config(pcie_port, bus_number, PCI_SLOT(devfn)) == 0) {
\r
1259 + *value = 0xffffffff;
\r
1260 + ret = PCIBIOS_DEVICE_NOT_FOUND;
\r
1264 + IFX_PCIE_PRINT(PCIE_MSG_READ_CFG, "%s: %02x:%02x.%01x/%02x:%01d\n", __func__, bus_number,
\r
1265 + PCI_SLOT(devfn), PCI_FUNC(devfn), where, size);
\r
1267 + PCIE_IRQ_LOCK(ifx_pcie_lock);
\r
1268 + if (bus_number == 0) { /* RC itself */
\r
1271 + t = (where & ~3);
\r
1272 + data = ifx_pcie_rc_cfg_rd(pcie_port, t);
\r
1273 + IFX_PCIE_PRINT(PCIE_MSG_READ_CFG, "%s: rd local cfg, offset:%08x, data:%08x\n",
\r
1274 + __func__, t, data);
\r
1277 + u32 addr = pcie_bus_addr(bus_number, devfn, where);
\r
1279 + data = ifx_pcie_cfg_rd(pcie_port, addr);
\r
1280 + if (pcie_port == IFX_PCIE_PORT0) {
\r
1281 + #ifdef CONFIG_IFX_PCIE_HW_SWAP
\r
1282 + data = le32_to_cpu(data);
\r
1283 + #endif /* CONFIG_IFX_PCIE_HW_SWAP */
\r
1286 + #ifdef CONFIG_IFX_PCIE1_HW_SWAP
\r
1287 + data = le32_to_cpu(data);
\r
1288 + #endif /* CONFIG_IFX_PCIE_HW_SWAP */
\r
1291 + /* To get a correct PCI topology, we have to restore the bus number to OS */
\r
1292 + data = ifx_pcie_bus_enum_hack(bus, devfn, where, data, pcie_port, 1);
\r
1294 + PCIE_IRQ_UNLOCK(ifx_pcie_lock);
\r
1295 + IFX_PCIE_PRINT(PCIE_MSG_READ_CFG, "%s: read config: data=%08x raw=%08x\n",
\r
1296 + __func__, (data >> (8 * (where & 3))) & mask[size & 7], data);
\r
1298 + *value = (data >> (8 * (where & 3))) & mask[size & 7];
\r
1304 +ifx_pcie_size_to_value(int where, int size, u32 data, u32 value)
\r
1307 + u32 tdata = data;
\r
1311 + shift = (where & 0x3) << 3;
\r
1312 + tdata &= ~(0xffU << shift);
\r
1313 + tdata |= ((value & 0xffU) << shift);
\r
1316 + shift = (where & 3) << 3;
\r
1317 + tdata &= ~(0xffffU << shift);
\r
1318 + tdata |= ((value & 0xffffU) << shift);
\r
1328 + * \fn static static int ifx_pcie_write_config(struct pci_bus *bus, u32 devfn,
\r
1329 + * int where, int size, u32 value)
\r
1330 + * \brief Write a value to PCI configuration space
\r
1332 + * \param[in] bus Pointer to pci bus
\r
1333 + * \param[in] devfn PCI device function number
\r
1334 + * \param[in] where PCI register number
\r
1335 + * \param[in] size The register size to be written
\r
1336 + * \param[in] value The valule to be written
\r
1337 + * \return PCIBIOS_BAD_REGISTER_NUMBER Invalid register number
\r
1338 + * \return PCIBIOS_DEVICE_NOT_FOUND PCI device not found
\r
1339 + * \return PCIBIOS_SUCCESSFUL OK
\r
1340 + * \ingroup IFX_PCIE_OS
\r
1343 +ifx_pcie_write_config(struct pci_bus *bus, u32 devfn,
\r
1344 + int where, int size, u32 value)
\r
1346 + int bus_number = bus->number;
\r
1347 + int ret = PCIBIOS_SUCCESSFUL;
\r
1348 + struct ifx_pci_controller *ctrl = bus->sysdata;
\r
1349 + int pcie_port = ctrl->port;
\r
1350 + u32 tvalue = value;
\r
1353 + /* Make sure the address is aligned to natural boundary */
\r
1354 + if (unlikely(((size - 1) & where))) {
\r
1355 + ret = PCIBIOS_BAD_REGISTER_NUMBER;
\r
1359 + * If we are second controller, we have to cheat OS so that it assume
\r
1360 + * its bus number starts from 0 in host controller
\r
1362 + bus_number = ifx_pcie_bus_nr_deduct(bus_number, pcie_port);
\r
1365 + * We need to force the bus number to be zero on the root
\r
1366 + * bus. Linux numbers the 2nd root bus to start after all
\r
1367 + * busses on root 0.
\r
1369 + if (bus->parent == NULL) {
\r
1370 + bus_number = 0;
\r
1373 + if (pcie_valid_config(pcie_port, bus_number, PCI_SLOT(devfn)) == 0) {
\r
1374 + ret = PCIBIOS_DEVICE_NOT_FOUND;
\r
1378 + IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG, "%s: %02x:%02x.%01x/%02x:%01d value=%08x\n", __func__,
\r
1379 + bus_number, PCI_SLOT(devfn), PCI_FUNC(devfn), where, size, value);
\r
1381 + /* XXX, some PCIe device may need some delay */
\r
1382 + PCIE_IRQ_LOCK(ifx_pcie_lock);
\r
1385 + * To configure the correct bus topology using native way, we have to cheat Os so that
\r
1386 + * it can configure the PCIe hardware correctly.
\r
1388 + tvalue = ifx_pcie_bus_enum_hack(bus, devfn, where, value, pcie_port, 0);
\r
1390 + if (bus_number == 0) { /* RC itself */
\r
1393 + t = (where & ~3);
\r
1394 + IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: wr local cfg, offset:%08x, fill:%08x\n", __func__, t, value);
\r
1395 + data = ifx_pcie_rc_cfg_rd(pcie_port, t);
\r
1396 + IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: rd local cfg, offset:%08x, data:%08x\n", __func__, t, data);
\r
1398 + data = ifx_pcie_size_to_value(where, size, data, tvalue);
\r
1400 + IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: wr local cfg, offset:%08x, value:%08x\n", __func__, t, data);
\r
1401 + ifx_pcie_rc_cfg_wr(pcie_port, t, data);
\r
1402 + IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: rd local cfg, offset:%08x, value:%08x\n",
\r
1403 + __func__, t, ifx_pcie_rc_cfg_rd(pcie_port, t));
\r
1406 + u32 addr = pcie_bus_addr(bus_number, devfn, where);
\r
1408 + IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: wr cfg, offset:%08x, fill:%08x\n", __func__, addr, value);
\r
1409 + data = ifx_pcie_cfg_rd(pcie_port, addr);
\r
1410 + if (pcie_port == IFX_PCIE_PORT0) {
\r
1411 + #ifdef CONFIG_IFX_PCIE_HW_SWAP
\r
1412 + data = le32_to_cpu(data);
\r
1413 + #endif /* CONFIG_IFX_PCIE_HW_SWAP */
\r
1416 + #ifdef CONFIG_IFX_PCIE1_HW_SWAP
\r
1417 + data = le32_to_cpu(data);
\r
1418 + #endif /* CONFIG_IFX_PCIE_HW_SWAP */
\r
1420 + IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: rd cfg, offset:%08x, data:%08x\n", __func__, addr, data);
\r
1422 + data = ifx_pcie_size_to_value(where, size, data, tvalue);
\r
1423 + if (pcie_port == IFX_PCIE_PORT0) {
\r
1424 + #ifdef CONFIG_IFX_PCIE_HW_SWAP
\r
1425 + data = cpu_to_le32(data);
\r
1426 + #endif /* CONFIG_IFX_PCIE_HW_SWAP */
\r
1429 + #ifdef CONFIG_IFX_PCIE1_HW_SWAP
\r
1430 + data = cpu_to_le32(data);
\r
1431 + #endif /* CONFIG_IFX_PCIE_HW_SWAP */
\r
1433 + IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG, "%s: wr cfg, offset:%08x, value:%08x\n", __func__, addr, data);
\r
1434 + ifx_pcie_cfg_wr(pcie_port, addr, data);
\r
1435 + IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG, "%s: rd cfg, offset:%08x, value:%08x\n",
\r
1436 + __func__, addr, ifx_pcie_cfg_rd(pcie_port, addr));
\r
1438 + PCIE_IRQ_UNLOCK(ifx_pcie_lock);
\r
1443 +static struct resource ifx_pcie_io_resource = {
\r
1444 + .name = "PCIe0 I/O space",
\r
1445 + .start = PCIE_IO_PHY_BASE,
\r
1446 + .end = PCIE_IO_PHY_END,
\r
1447 + .flags = IORESOURCE_IO,
\r
1450 +static struct resource ifx_pcie_mem_resource = {
\r
1451 + .name = "PCIe0 Memory space",
\r
1452 + .start = PCIE_MEM_PHY_BASE,
\r
1453 + .end = PCIE_MEM_PHY_END,
\r
1454 + .flags = IORESOURCE_MEM,
\r
1457 +static struct pci_ops ifx_pcie_ops = {
\r
1458 + .read = ifx_pcie_read_config,
\r
1459 + .write = ifx_pcie_write_config,
\r
1462 +#ifdef CONFIG_IFX_PCIE_2ND_CORE
\r
1463 +static struct resource ifx_pcie1_io_resource = {
\r
1464 + .name = "PCIe1 I/O space",
\r
1465 + .start = PCIE1_IO_PHY_BASE,
\r
1466 + .end = PCIE1_IO_PHY_END,
\r
1467 + .flags = IORESOURCE_IO,
\r
1470 +static struct resource ifx_pcie1_mem_resource = {
\r
1471 + .name = "PCIe1 Memory space",
\r
1472 + .start = PCIE1_MEM_PHY_BASE,
\r
1473 + .end = PCIE1_MEM_PHY_END,
\r
1474 + .flags = IORESOURCE_MEM,
\r
1476 +#endif /* CONFIG_IFX_PCIE_2ND_CORE */
\r
1478 +static struct ifx_pci_controller ifx_pcie_controller[IFX_PCIE_CORE_NR] = {
\r
1481 + .pci_ops = &ifx_pcie_ops,
\r
1482 + .mem_resource = &ifx_pcie_mem_resource,
\r
1483 + .io_resource = &ifx_pcie_io_resource,
\r
1485 + .port = IFX_PCIE_PORT0,
\r
1487 +#ifdef CONFIG_IFX_PCIE_2ND_CORE
\r
1490 + .pci_ops = &ifx_pcie_ops,
\r
1491 + .mem_resource = &ifx_pcie1_mem_resource,
\r
1492 + .io_resource = &ifx_pcie1_io_resource,
\r
1494 + .port = IFX_PCIE_PORT1,
\r
1496 +#endif /* CONFIG_IFX_PCIE_2ND_CORE */
\r
1499 +#ifdef IFX_PCIE_ERROR_INT
\r
1500 +static INLINE void
\r
1501 +pcie_core_int_clear_all(int pcie_port)
\r
1505 + reg = IFX_REG_R32(PCIE_IRNCR(pcie_port));
\r
1506 + IFX_PCIE_PRINT(PCIE_MSG_ISR, "%s PCIE_IRNCR: 0x%08x\n",
\r
1507 + __func__, IFX_REG_R32(PCIE_IRNCR(pcie_port)));
\r
1508 + reg &= PCIE_RC_CORE_COMBINED_INT;
\r
1509 + IFX_REG_W32(reg, PCIE_IRNCR(pcie_port));
\r
1512 +static irqreturn_t
\r
1513 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
\r
1514 +pcie_rc_core_isr(int irq, void *dev_id)
\r
1516 +pcie_rc_core_isr(int irq, void *dev_id, struct pt_regs *regs)
\r
1519 + struct ifx_pci_controller *ctrl = (struct ifx_pci_controller *)dev_id;
\r
1520 + int pcie_port = ctrl->port;
\r
1522 + IFX_PCIE_PRINT(PCIE_MSG_ISR, "PCIe RC error intr %d\n", irq);
\r
1523 + pcie_core_int_clear_all(pcie_port);
\r
1524 + return IRQ_HANDLED;
\r
1528 +pcie_rc_core_int_init(int pcie_port)
\r
1532 + IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s enter \n", __func__);
\r
1534 + /* Enable core interrupt */
\r
1535 + IFX_REG_SET_BIT(PCIE_RC_CORE_COMBINED_INT, PCIE_IRNEN(pcie_port));
\r
1536 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_IRNEN: 0x%08x\n",
\r
1537 + __func__, IFX_REG_R32(PCIE_IRNEN(pcie_port)));
\r
1539 + /* Clear it first */
\r
1540 + IFX_REG_SET_BIT(PCIE_RC_CORE_COMBINED_INT, PCIE_IRNCR(pcie_port));
\r
1541 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_IRNCR: 0x%08x\n",
\r
1542 + __func__, IFX_REG_R32(PCIE_IRNCR(pcie_port)));
\r
1543 + ret = request_irq(pcie_irqs[pcie_port].ir_irq.irq, pcie_rc_core_isr, IRQF_DISABLED,
\r
1544 + pcie_irqs[pcie_port].ir_irq.name, &ifx_pcie_controller[pcie_port]);
\r
1546 + printk(KERN_ERR "%s request irq %d failed\n", __func__, IFX_PCIE_IR);
\r
1548 + IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s exit \n", __func__);
\r
1552 +#endif /* IFX_PCIE_ERROR_INT */
\r
1555 + * \fn int ifx_pcie_bios_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
\r
1556 + * \brief Map a PCI device to the appropriate interrupt line
\r
1558 + * \param[in] dev The Linux PCI device structure for the device to map
\r
1559 + * \param[in] slot The slot number for this device on __BUS 0__. Linux
\r
1560 + * enumerates through all the bridges and figures out the
\r
1561 + * slot on Bus 0 where this device eventually hooks to.
\r
1562 + * \param[in] pin The PCI interrupt pin read from the device, then swizzled
\r
1563 + * as it goes through each bridge.
\r
1564 + * \return Interrupt number for the device
\r
1565 + * \ingroup IFX_PCIE_OS
\r
1568 +ifx_pcie_bios_map_irq(IFX_PCI_CONST struct pci_dev *dev, u8 slot, u8 pin)
\r
1570 + u32 irq_bit = 0;
\r
1572 + struct ifx_pci_controller *ctrl = dev->bus->sysdata;
\r
1573 + int pcie_port = ctrl->port;
\r
1575 + printk("%s port %d dev %s slot %d pin %d \n", __func__, pcie_port, pci_name(dev), slot, pin);
\r
1577 + if ((pin == PCIE_LEGACY_DISABLE) || (pin > PCIE_LEGACY_INT_MAX)) {
\r
1578 + printk(KERN_WARNING "WARNING: dev %s: invalid interrupt pin %d\n", pci_name(dev), pin);
\r
1581 + /* Pin index so minus one */
\r
1582 + irq_bit = pcie_irqs[pcie_port].legacy_irq[pin - 1].irq_bit;
\r
1583 + irq = pcie_irqs[pcie_port].legacy_irq[pin - 1].irq;
\r
1584 + IFX_REG_SET_BIT(irq_bit, PCIE_IRNEN(pcie_port));
\r
1585 +// printk("%s PCIE_IRNEN: 0x%08x\n", __func__, IFX_REG_R32(PCIE_IRNEN(pcie_port)));
\r
1586 + IFX_REG_SET_BIT(irq_bit, PCIE_IRNCR(pcie_port));
\r
1587 + // printk("%s PCIE_IRNCR: 0x%08x\n", __func__, IFX_REG_R32(PCIE_IRNCR(pcie_port)));
\r
1588 + printk("%s dev %s irq %d assigned\n", __func__, pci_name(dev), irq);
\r
1589 +// printk("%s dev %s: exit\n", __func__, pci_name(dev));
\r
1594 + * \fn int ifx_pcie_bios_plat_dev_init(struct pci_dev *dev)
\r
1595 + * \brief Called to perform platform specific PCI setup
\r
1597 + * \param[in] dev The Linux PCI device structure for the device to map
\r
1599 + * \ingroup IFX_PCIE_OS
\r
1602 +ifx_pcie_bios_plat_dev_init(struct pci_dev *dev)
\r
1605 +#ifdef IFX_PCIE_ERROR_INT
\r
1608 +#endif /* IFX_PCIE_ERROR_INT */
\r
1610 + IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s enter \n", __func__);
\r
1611 + /* Enable reporting System errors and parity errors on all devices */
\r
1612 + /* Enable parity checking and error reporting */
\r
1613 + pci_read_config_word(dev, PCI_COMMAND, &config);
\r
1614 + config |= PCI_COMMAND_PARITY | PCI_COMMAND_SERR /*| PCI_COMMAND_INVALIDATE |
\r
1615 + PCI_COMMAND_FAST_BACK*/;
\r
1616 + pci_write_config_word(dev, PCI_COMMAND, config);
\r
1618 + if (dev->subordinate) {
\r
1619 + /* Set latency timers on sub bridges */
\r
1620 + pci_write_config_byte(dev, PCI_SEC_LATENCY_TIMER, 0x40); /* XXX, */
\r
1621 + /* More bridge error detection */
\r
1622 + pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &config);
\r
1623 + config |= PCI_BRIDGE_CTL_PARITY | PCI_BRIDGE_CTL_SERR;
\r
1624 + pci_write_config_word(dev, PCI_BRIDGE_CONTROL, config);
\r
1626 +#ifdef IFX_PCIE_ERROR_INT
\r
1627 + /* Enable the PCIe normal error reporting */
\r
1628 + pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
\r
1631 + /* Disable system error generation in response to error messages */
\r
1632 + pci_read_config_word(dev, pos + PCI_EXP_RTCTL, &config);
\r
1633 + config &= ~(PCI_EXP_RTCTL_SECEE | PCI_EXP_RTCTL_SENFEE | PCI_EXP_RTCTL_SEFEE);
\r
1634 + pci_write_config_word(dev, pos + PCI_EXP_RTCTL, config);
\r
1636 + /* Clear PCIE Capability's Device Status */
\r
1637 + pci_read_config_word(dev, pos + PCI_EXP_DEVSTA, &config);
\r
1638 + pci_write_config_word(dev, pos + PCI_EXP_DEVSTA, config);
\r
1640 + /* Update Device Control */
\r
1641 + pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &config);
\r
1642 + /* Correctable Error Reporting */
\r
1643 + config |= PCI_EXP_DEVCTL_CERE;
\r
1644 + /* Non-Fatal Error Reporting */
\r
1645 + config |= PCI_EXP_DEVCTL_NFERE;
\r
1646 + /* Fatal Error Reporting */
\r
1647 + config |= PCI_EXP_DEVCTL_FERE;
\r
1648 + /* Unsupported Request */
\r
1649 + config |= PCI_EXP_DEVCTL_URRE;
\r
1650 + pci_write_config_word(dev, pos + PCI_EXP_DEVCTL, config);
\r
1653 + /* Find the Advanced Error Reporting capability */
\r
1654 + pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
\r
1656 + /* Clear Uncorrectable Error Status */
\r
1657 + pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS, &dconfig);
\r
1658 + pci_write_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS, dconfig);
\r
1659 + /* Enable reporting of all uncorrectable errors */
\r
1660 + /* Uncorrectable Error Mask - turned on bits disable errors */
\r
1661 + pci_write_config_dword(dev, pos + PCI_ERR_UNCOR_MASK, 0);
\r
1663 + * Leave severity at HW default. This only controls if
\r
1664 + * errors are reported as uncorrectable or
\r
1665 + * correctable, not if the error is reported.
\r
1667 + /* PCI_ERR_UNCOR_SEVER - Uncorrectable Error Severity */
\r
1668 + /* Clear Correctable Error Status */
\r
1669 + pci_read_config_dword(dev, pos + PCI_ERR_COR_STATUS, &dconfig);
\r
1670 + pci_write_config_dword(dev, pos + PCI_ERR_COR_STATUS, dconfig);
\r
1671 + /* Enable reporting of all correctable errors */
\r
1672 + /* Correctable Error Mask - turned on bits disable errors */
\r
1673 + pci_write_config_dword(dev, pos + PCI_ERR_COR_MASK, 0);
\r
1674 + /* Advanced Error Capabilities */
\r
1675 + pci_read_config_dword(dev, pos + PCI_ERR_CAP, &dconfig);
\r
1676 + /* ECRC Generation Enable */
\r
1677 + if (dconfig & PCI_ERR_CAP_ECRC_GENC) {
\r
1678 + dconfig |= PCI_ERR_CAP_ECRC_GENE;
\r
1680 + /* ECRC Check Enable */
\r
1681 + if (dconfig & PCI_ERR_CAP_ECRC_CHKC) {
\r
1682 + dconfig |= PCI_ERR_CAP_ECRC_CHKE;
\r
1684 + pci_write_config_dword(dev, pos + PCI_ERR_CAP, dconfig);
\r
1686 + /* PCI_ERR_HEADER_LOG - Header Log Register (16 bytes) */
\r
1687 + /* Enable Root Port's interrupt in response to error messages */
\r
1688 + pci_write_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND,
\r
1689 + PCI_ERR_ROOT_CMD_COR_EN |
\r
1690 + PCI_ERR_ROOT_CMD_NONFATAL_EN |
\r
1691 + PCI_ERR_ROOT_CMD_FATAL_EN);
\r
1692 + /* Clear the Root status register */
\r
1693 + pci_read_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, &dconfig);
\r
1694 + pci_write_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, dconfig);
\r
1696 +#endif /* IFX_PCIE_ERROR_INT */
\r
1697 + /* WAR, only 128 MRRS is supported, force all EPs to support this value */
\r
1698 + pcie_set_readrq(dev, 128);
\r
1699 + IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s exit \n", __func__);
\r
1704 +pcie_phy_rst(int pcie_port)
\r
1706 + pcie_phy_rst_assert(pcie_port);
\r
1707 + pcie_phy_rst_deassert(pcie_port);
\r
1709 + /* Make sure PHY PLL is stable */
\r
1714 +pcie_rc_initialize(int pcie_port)
\r
1717 +#define IFX_PCIE_PHY_LOOP_CNT 5
\r
1719 + pcie_rcu_endian_setup(pcie_port);
\r
1721 + pcie_ep_gpio_rst_init(pcie_port);
\r
1724 + * XXX, PCIe elastic buffer bug will cause not to be detected. One more
\r
1725 + * reset PCIe PHY will solve this issue
\r
1727 + for (i = 0; i < IFX_PCIE_PHY_LOOP_CNT; i++) {
\r
1728 + /* Disable PCIe PHY Analog part for sanity check */
\r
1729 + pcie_phy_pmu_disable(pcie_port);
\r
1731 + pcie_phy_rst(pcie_port);
\r
1733 + /* PCIe Core reset enabled, low active, sw programmed */
\r
1734 + pcie_core_rst_assert(pcie_port);
\r
1736 + /* Put PCIe EP in reset status */
\r
1737 + pcie_device_rst_assert(pcie_port);
\r
1739 + /* PCI PHY & Core reset disabled, high active, sw programmed */
\r
1740 + pcie_core_rst_deassert(pcie_port);
\r
1742 + /* Already in a quiet state, program PLL, enable PHY, check ready bit */
\r
1743 + pcie_phy_clock_mode_setup(pcie_port);
\r
1745 + /* Enable PCIe PHY and Clock */
\r
1746 + pcie_core_pmu_setup(pcie_port);
\r
1748 + /* Clear status registers */
\r
1749 + pcie_status_register_clear(pcie_port);
\r
1751 + #ifdef CONFIG_PCI_MSI
\r
1752 + pcie_msi_init(pcie_port);
\r
1753 + #endif /* CONFIG_PCI_MSI */
\r
1754 + pcie_rc_cfg_reg_setup(pcie_port);
\r
1756 + /* Once link is up, break out */
\r
1757 + if (pcie_app_loigc_setup(pcie_port) == 0) {
\r
1761 + if (i >= IFX_PCIE_PHY_LOOP_CNT) {
\r
1762 + printk(KERN_ERR "%s link up failed!!!!!\n", __func__);
\r
1765 + /* NB, don't increase ACK/NACK timer timeout value, which will cause a lot of COR errors */
\r
1766 + pcie_replay_time_update(pcie_port);
\r
1767 +#ifdef IFX_PCIE_DBG
\r
1768 + pcie_post_dump(pcie_port);
\r
1769 + pcie_status_registers_dump(pcie_port);
\r
1770 +#endif /* IFX_PCIE_DBG */
\r
1774 +static int inline
\r
1775 +ifx_pcie_startup_port_nr(void)
\r
1777 + int pcie_port = IFX_PCIE_PORT0;
\r
1779 +#if defined (CONFIG_IFX_PCIE_1ST_CORE) && defined (CONFIG_IFX_PCIE_2ND_CORE)
\r
1780 + pcie_port = IFX_PCIE_PORT0;
\r
1781 +#elif defined (CONFIG_IFX_PCIE_1ST_CORE)
\r
1782 + pcie_port = IFX_PCIE_PORT0;
\r
1783 +#elif defined (CONFIG_IFX_PCIE_2ND_CORE)
\r
1784 + pcie_port = IFX_PCIE_PORT1;
\r
1786 + #error "Please choose valid PCIe Core"
\r
1788 + return pcie_port;
\r
1792 + * \fn static int __init ifx_pcie_bios_init(void)
\r
1793 + * \brief Initialize the IFX PCIe controllers
\r
1795 + * \return -EIO PCIe PHY link is not up
\r
1796 + * \return -ENOMEM Configuration/IO space failed to map
\r
1798 + * \ingroup IFX_PCIE_OS
\r
1800 +extern int (*ltq_pci_plat_arch_init)(struct pci_dev *dev);
\r
1801 +extern int (*ltq_pci_map_irq)(const struct pci_dev *dev, u8 slot, u8 pin);
\r
1803 +static int __init
\r
1804 +ifx_pcie_bios_init(void)
\r
1806 + char ver_str[128] = {0};
\r
1807 + void __iomem *io_map_base;
\r
1809 + int startup_port;
\r
1811 + IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s enter \n", __func__);
\r
1813 + ltq_pci_map_irq = ifx_pcie_bios_map_irq;
\r
1814 + ltq_pci_plat_arch_init = ifx_pcie_bios_plat_dev_init;
\r
1816 + /* Enable AHB Master/ Slave */
\r
1817 + pcie_ahb_pmu_setup();
\r
1819 + startup_port = ifx_pcie_startup_port_nr();
\r
1821 + for (pcie_port = startup_port; pcie_port < IFX_PCIE_CORE_NR; pcie_port++){
\r
1822 + if (pcie_rc_initialize(pcie_port) == 0) {
\r
1823 + IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s: ifx_pcie_cfg_base 0x%p\n",
\r
1824 + __func__, PCIE_CFG_PORT_TO_BASE(pcie_port));
\r
1825 + /* Otherwise, warning will pop up */
\r
1826 + io_map_base = ioremap(PCIE_IO_PHY_PORT_TO_BASE(pcie_port), PCIE_IO_SIZE);
\r
1827 + if (io_map_base == NULL) {
\r
1828 + IFX_PCIE_PRINT(PCIE_MSG_ERR, "%s io space ioremap failed\n", __func__);
\r
1831 + ifx_pcie_controller[pcie_port].pcic.io_map_base = (unsigned long)io_map_base;
\r
1833 + register_pci_controller(&ifx_pcie_controller[pcie_port].pcic);
\r
1834 + /* XXX, clear error status */
\r
1836 + IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s: mem_resource 0x%p, io_resource 0x%p\n",
\r
1837 + __func__, &ifx_pcie_controller[pcie_port].pcic.mem_resource,
\r
1838 + &ifx_pcie_controller[pcie_port].pcic.io_resource);
\r
1840 + #ifdef IFX_PCIE_ERROR_INT
\r
1841 + pcie_rc_core_int_init(pcie_port);
\r
1842 + #endif /* IFX_PCIE_ERROR_INT */
\r
1845 +#ifdef CONFIG_IFX_PMCU
\r
1846 + ifx_pcie_pmcu_init();
\r
1847 +#endif /* CONFIG_IFX_PMCU */
\r
1849 + sprintf(ver_str, "PCIe Root Complex %d.%d.%d", IFX_PCIE_VER_MAJOR, IFX_PCIE_VER_MID, IFX_PCIE_VER_MINOR);
\r
1850 + printk(KERN_INFO "%s", ver_str);
\r
1852 +#undef IFX_PCIE_PHY_LOOP_CNT
\r
1854 +arch_initcall(ifx_pcie_bios_init);
\r
1856 +MODULE_LICENSE("GPL");
\r
1857 +MODULE_AUTHOR("Chuanhua.Lei@infineon.com");
\r
1858 +MODULE_SUPPORTED_DEVICE("Infineon builtin PCIe RC module");
\r
1859 +MODULE_DESCRIPTION("Infineon builtin PCIe RC driver");
\r
1862 +++ b/arch/mips/pci/ifxmips_pcie.h
1864 +/******************************************************************************
\r
1866 +** FILE NAME : ifxmips_pcie.h
\r
1867 +** PROJECT : IFX UEIP for VRX200
\r
1868 +** MODULES : PCIe module
\r
1870 +** DATE : 02 Mar 2009
\r
1871 +** AUTHOR : Lei Chuanhua
\r
1872 +** DESCRIPTION : PCIe Root Complex Driver
\r
1873 +** COPYRIGHT : Copyright (c) 2009
\r
1874 +** Infineon Technologies AG
\r
1875 +** Am Campeon 1-12, 85579 Neubiberg, Germany
\r
1877 +** This program is free software; you can redistribute it and/or modify
\r
1878 +** it under the terms of the GNU General Public License as published by
\r
1879 +** the Free Software Foundation; either version 2 of the License, or
\r
1880 +** (at your option) any later version.
\r
1882 +** $Version $Date $Author $Comment
\r
1883 +** 0.0.1 17 Mar,2009 Lei Chuanhua Initial version
\r
1884 +*******************************************************************************/
\r
1885 +#ifndef IFXMIPS_PCIE_H
\r
1886 +#define IFXMIPS_PCIE_H
\r
1887 +#include <linux/version.h>
\r
1888 +#include <linux/types.h>
\r
1889 +#include <linux/pci.h>
\r
1890 +#include <linux/interrupt.h>
\r
1891 +#include "ifxmips_pci_common.h"
\r
1892 +#include "ifxmips_pcie_reg.h"
\r
1895 + \defgroup IFX_PCIE PCI Express bus driver module
\r
1896 + \brief PCI Express IP module support VRX200
\r
1900 + \defgroup IFX_PCIE_OS OS APIs
\r
1901 + \ingroup IFX_PCIE
\r
1902 + \brief PCIe bus driver OS interface functions
\r
1906 + \file ifxmips_pcie.h
\r
1907 + \ingroup IFX_PCIE
\r
1908 + \brief header file for PCIe module common header file
\r
1910 +#define PCIE_IRQ_LOCK(lock) do { \
\r
1911 + unsigned long flags; \
\r
1912 + spin_lock_irqsave(&(lock), flags);
\r
1913 +#define PCIE_IRQ_UNLOCK(lock) \
\r
1914 + spin_unlock_irqrestore(&(lock), flags); \
\r
1917 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
\r
1918 +#define IRQF_SHARED SA_SHIRQ
\r
1921 +#define PCIE_MSG_MSI 0x00000001
\r
1922 +#define PCIE_MSG_ISR 0x00000002
\r
1923 +#define PCIE_MSG_FIXUP 0x00000004
\r
1924 +#define PCIE_MSG_READ_CFG 0x00000008
\r
1925 +#define PCIE_MSG_WRITE_CFG 0x00000010
\r
1926 +#define PCIE_MSG_CFG (PCIE_MSG_READ_CFG | PCIE_MSG_WRITE_CFG)
\r
1927 +#define PCIE_MSG_REG 0x00000020
\r
1928 +#define PCIE_MSG_INIT 0x00000040
\r
1929 +#define PCIE_MSG_ERR 0x00000080
\r
1930 +#define PCIE_MSG_PHY 0x00000100
\r
1931 +#define PCIE_MSG_ANY 0x000001ff
\r
1933 +#define IFX_PCIE_PORT0 0
\r
1934 +#define IFX_PCIE_PORT1 1
\r
1936 +#ifdef CONFIG_IFX_PCIE_2ND_CORE
\r
1937 +#define IFX_PCIE_CORE_NR 2
\r
1939 +#define IFX_PCIE_CORE_NR 1
\r
1942 +#define IFX_PCIE_ERROR_INT
\r
1944 +//#define IFX_PCIE_DBG
\r
1946 +#if defined(IFX_PCIE_DBG)
\r
1947 +#define IFX_PCIE_PRINT(_m, _fmt, args...) do { \
\r
1948 + ifx_pcie_debug((_fmt), ##args); \
\r
1953 +#define IFX_PCIE_PRINT(_m, _fmt, args...) \
\r
1955 +#define INLINE inline
\r
1958 +struct ifx_pci_controller {
\r
1959 + struct pci_controller pcic;
\r
1961 + /* RC specific, per host bus information */
\r
1962 + u32 port; /* Port index, 0 -- 1st core, 1 -- 2nd core */
\r
1965 +typedef struct ifx_pcie_ir_irq {
\r
1966 + const unsigned int irq;
\r
1967 + const char name[16];
\r
1968 +}ifx_pcie_ir_irq_t;
\r
1970 +typedef struct ifx_pcie_legacy_irq{
\r
1971 + const u32 irq_bit;
\r
1973 +}ifx_pcie_legacy_irq_t;
\r
1975 +typedef struct ifx_pcie_irq {
\r
1976 + ifx_pcie_ir_irq_t ir_irq;
\r
1977 + ifx_pcie_legacy_irq_t legacy_irq[PCIE_LEGACY_INT_MAX];
\r
1980 +extern u32 g_pcie_debug_flag;
\r
1981 +extern void ifx_pcie_debug(const char *fmt, ...);
\r
1982 +extern void pcie_phy_clock_mode_setup(int pcie_port);
\r
1983 +extern void pcie_msi_pic_init(int pcie_port);
\r
1984 +extern u32 ifx_pcie_bus_enum_read_hack(int where, u32 value);
\r
1985 +extern u32 ifx_pcie_bus_enum_write_hack(int where, u32 value);
\r
1987 +#define CONFIG_VR9
\r
1989 +#ifdef CONFIG_VR9
\r
1990 +#include "ifxmips_pcie_vr9.h"
\r
1991 +#elif defined (CONFIG_AR10)
\r
1992 +#include "ifxmips_pcie_ar10.h"
\r
1994 +#error "PCIE: platform not defined"
\r
1995 +#endif /* CONFIG_VR9 */
\r
1997 +#endif /* IFXMIPS_PCIE_H */
\r
2000 +++ b/arch/mips/pci/ifxmips_pcie_ar10.h
2002 +/****************************************************************************
2003 + Copyright (c) 2010
2004 + Lantiq Deutschland GmbH
2005 + Am Campeon 3; 85579 Neubiberg, Germany
2007 + For licensing information, see the file 'LICENSE' in the root folder of
2008 + this software module.
2010 + *****************************************************************************/
2012 + \file ifxmips_pcie_ar10.h
2014 + \brief PCIe RC driver ar10 specific file
2017 +#ifndef IFXMIPS_PCIE_AR10_H
2018 +#define IFXMIPS_PCIE_AR10_H
2019 +#ifndef AUTOCONF_INCLUDED
2020 +#include <linux/config.h>
2021 +#endif /* AUTOCONF_INCLUDED */
2022 +#include <linux/types.h>
2023 +#include <linux/delay.h>
2025 +/* Project header file */
2026 +#include <asm/ifx/ifx_types.h>
2027 +#include <asm/ifx/ifx_pmu.h>
2028 +#include <asm/ifx/ifx_gpio.h>
2029 +#include <asm/ifx/ifx_ebu_led.h>
2031 +static inline void pcie_ep_gpio_rst_init(int pcie_port)
2033 + ifx_ebu_led_enable();
2034 + if (pcie_port == 0) {
2035 + ifx_ebu_led_set_data(11, 1);
2038 + ifx_ebu_led_set_data(12, 1);
2042 +static inline void pcie_ahb_pmu_setup(void)
2044 + /* XXX, moved to CGU to control AHBM */
2047 +static inline void pcie_rcu_endian_setup(int pcie_port)
2051 + reg = IFX_REG_R32(IFX_RCU_AHB_ENDIAN);
2052 + /* Inbound, big endian */
2053 + reg |= IFX_RCU_BE_AHB4S;
2054 + if (pcie_port == 0) {
2055 + reg |= IFX_RCU_BE_PCIE0M;
2057 + #ifdef CONFIG_IFX_PCIE_HW_SWAP
2058 + /* Outbound, software swap needed */
2059 + reg |= IFX_RCU_BE_AHB3M;
2060 + reg &= ~IFX_RCU_BE_PCIE0S;
2062 + /* Outbound little endian */
2063 + reg &= ~IFX_RCU_BE_AHB3M;
2064 + reg &= ~IFX_RCU_BE_PCIE0S;
2068 + reg |= IFX_RCU_BE_PCIE1M;
2069 + #ifdef CONFIG_IFX_PCIE1_HW_SWAP
2070 + /* Outbound, software swap needed */
2071 + reg |= IFX_RCU_BE_AHB3M;
2072 + reg &= ~IFX_RCU_BE_PCIE1S;
2074 + /* Outbound little endian */
2075 + reg &= ~IFX_RCU_BE_AHB3M;
2076 + reg &= ~IFX_RCU_BE_PCIE1S;
2080 + IFX_REG_W32(reg, IFX_RCU_AHB_ENDIAN);
2081 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s IFX_RCU_AHB_ENDIAN: 0x%08x\n", __func__, IFX_REG_R32(IFX_RCU_AHB_ENDIAN));
2084 +static inline void pcie_phy_pmu_enable(int pcie_port)
2086 + if (pcie_port == 0) { /* XXX, should use macro*/
2087 + PCIE0_PHY_PMU_SETUP(IFX_PMU_ENABLE);
2090 + PCIE1_PHY_PMU_SETUP(IFX_PMU_ENABLE);
2094 +static inline void pcie_phy_pmu_disable(int pcie_port)
2096 + if (pcie_port == 0) { /* XXX, should use macro*/
2097 + PCIE0_PHY_PMU_SETUP(IFX_PMU_DISABLE);
2100 + PCIE1_PHY_PMU_SETUP(IFX_PMU_DISABLE);
2104 +static inline void pcie_pdi_big_endian(int pcie_port)
2108 + reg = IFX_REG_R32(IFX_RCU_AHB_ENDIAN);
2109 + if (pcie_port == 0) {
2110 + /* Config AHB->PCIe and PDI endianness */
2111 + reg |= IFX_RCU_BE_PCIE0_PDI;
2114 + /* Config AHB->PCIe and PDI endianness */
2115 + reg |= IFX_RCU_BE_PCIE1_PDI;
2117 + IFX_REG_W32(reg, IFX_RCU_AHB_ENDIAN);
2120 +static inline void pcie_pdi_pmu_enable(int pcie_port)
2122 + if (pcie_port == 0) {
2123 + /* Enable PDI to access PCIe PHY register */
2124 + PDI0_PMU_SETUP(IFX_PMU_ENABLE);
2127 + PDI1_PMU_SETUP(IFX_PMU_ENABLE);
2131 +static inline void pcie_core_rst_assert(int pcie_port)
2135 + reg = IFX_REG_R32(IFX_RCU_RST_REQ);
2137 + /* Reset Core, bit 22 */
2138 + if (pcie_port == 0) {
2139 + reg |= 0x00400000;
2142 + reg |= 0x08000000; /* Bit 27 */
2144 + IFX_REG_W32(reg, IFX_RCU_RST_REQ);
2147 +static inline void pcie_core_rst_deassert(int pcie_port)
2151 + /* Make sure one micro-second delay */
2154 + reg = IFX_REG_R32(IFX_RCU_RST_REQ);
2155 + if (pcie_port == 0) {
2156 + reg &= ~0x00400000; /* bit 22 */
2159 + reg &= ~0x08000000; /* Bit 27 */
2161 + IFX_REG_W32(reg, IFX_RCU_RST_REQ);
2164 +static inline void pcie_phy_rst_assert(int pcie_port)
2168 + reg = IFX_REG_R32(IFX_RCU_RST_REQ);
2169 + if (pcie_port == 0) {
2170 + reg |= 0x00001000; /* Bit 12 */
2173 + reg |= 0x00002000; /* Bit 13 */
2175 + IFX_REG_W32(reg, IFX_RCU_RST_REQ);
2178 +static inline void pcie_phy_rst_deassert(int pcie_port)
2182 + /* Make sure one micro-second delay */
2185 + reg = IFX_REG_R32(IFX_RCU_RST_REQ);
2186 + if (pcie_port == 0) {
2187 + reg &= ~0x00001000; /* Bit 12 */
2190 + reg &= ~0x00002000; /* Bit 13 */
2192 + IFX_REG_W32(reg, IFX_RCU_RST_REQ);
2195 +static inline void pcie_device_rst_assert(int pcie_port)
2197 + if (pcie_port == 0) {
2198 + ifx_ebu_led_set_data(11, 0);
2201 + ifx_ebu_led_set_data(12, 0);
2205 +static inline void pcie_device_rst_deassert(int pcie_port)
2208 + if (pcie_port == 0) {
2209 + ifx_ebu_led_set_data(11, 1);
2212 + ifx_ebu_led_set_data(12, 1);
2214 + ifx_ebu_led_disable();
2217 +static inline void pcie_core_pmu_setup(int pcie_port)
2219 + if (pcie_port == 0) {
2220 + PCIE0_CTRL_PMU_SETUP(IFX_PMU_ENABLE);
2223 + PCIE1_CTRL_PMU_SETUP(IFX_PMU_ENABLE);
2227 +static inline void pcie_msi_init(int pcie_port)
2229 + pcie_msi_pic_init(pcie_port);
2230 + if (pcie_port == 0) {
2231 + MSI0_PMU_SETUP(IFX_PMU_ENABLE);
2234 + MSI1_PMU_SETUP(IFX_PMU_ENABLE);
2239 +ifx_pcie_bus_nr_deduct(u32 bus_number, int pcie_port)
2241 + u32 tbus_number = bus_number;
2243 +#ifdef CONFIG_IFX_PCIE_2ND_CORE
2244 + if (pcie_port == IFX_PCIE_PORT1) { /* Port 1 must check if there are two cores enabled */
2245 + if (pcibios_host_nr() > 1) {
2246 + tbus_number -= pcibios_1st_host_bus_nr();
2249 +#endif /* CONFIG_IFX_PCI */
2250 + return tbus_number;
2254 +ifx_pcie_bus_enum_hack(struct pci_bus *bus, u32 devfn, int where, u32 value, int pcie_port, int read)
2256 + struct pci_dev *pdev;
2257 + u32 tvalue = value;
2259 + /* Sanity check */
2260 + pdev = pci_get_slot(bus, devfn);
2261 + if (pdev == NULL) {
2265 + /* Only care about PCI bridge */
2266 + if (pdev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
2270 + if (read) { /* Read hack */
2271 + #ifdef CONFIG_IFX_PCIE_2ND_CORE
2272 + if (pcie_port == IFX_PCIE_PORT1) { /* Port 1 must check if there are two cores enabled */
2273 + if (pcibios_host_nr() > 1) {
2274 + tvalue = ifx_pcie_bus_enum_read_hack(where, tvalue);
2277 + #endif /* CONFIG_IFX_PCIE_2ND_CORE */
2279 + else { /* Write hack */
2280 + #ifdef CONFIG_IFX_PCIE_2ND_CORE
2281 + if (pcie_port == IFX_PCIE_PORT1) { /* Port 1 must check if there are two cores enabled */
2282 + if (pcibios_host_nr() > 1) {
2283 + tvalue = ifx_pcie_bus_enum_write_hack(where, tvalue);
2291 +#endif /* IFXMIPS_PCIE_AR10_H */
2293 +++ b/arch/mips/pci/ifxmips_pcie_msi.c
2295 +/******************************************************************************
\r
2297 +** FILE NAME : ifxmips_pcie_msi.c
\r
2298 +** PROJECT : IFX UEIP for VRX200
\r
2299 +** MODULES : PCI MSI sub module
\r
2301 +** DATE : 02 Mar 2009
\r
2302 +** AUTHOR : Lei Chuanhua
\r
2303 +** DESCRIPTION : PCIe MSI Driver
\r
2304 +** COPYRIGHT : Copyright (c) 2009
\r
2305 +** Infineon Technologies AG
\r
2306 +** Am Campeon 1-12, 85579 Neubiberg, Germany
\r
2308 +** This program is free software; you can redistribute it and/or modify
\r
2309 +** it under the terms of the GNU General Public License as published by
\r
2310 +** the Free Software Foundation; either version 2 of the License, or
\r
2311 +** (at your option) any later version.
\r
2313 +** $Date $Author $Comment
\r
2314 +** 02 Mar,2009 Lei Chuanhua Initial version
\r
2315 +*******************************************************************************/
\r
2317 + \defgroup IFX_PCIE_MSI MSI OS APIs
\r
2318 + \ingroup IFX_PCIE
\r
2319 + \brief PCIe bus driver OS interface functions
\r
2323 + \file ifxmips_pcie_msi.c
\r
2324 + \ingroup IFX_PCIE
\r
2325 + \brief PCIe MSI OS interface file
\r
2328 +#ifndef AUTOCONF_INCLUDED
\r
2329 +#include <linux/config.h>
\r
2330 +#endif /* AUTOCONF_INCLUDED */
\r
2331 +#include <linux/init.h>
\r
2332 +#include <linux/sched.h>
\r
2333 +#include <linux/slab.h>
\r
2334 +#include <linux/interrupt.h>
\r
2335 +#include <linux/kernel_stat.h>
\r
2336 +#include <linux/pci.h>
\r
2337 +#include <linux/msi.h>
\r
2338 +#include <linux/module.h>
\r
2339 +#include <asm/bootinfo.h>
\r
2340 +#include <asm/irq.h>
\r
2341 +#include <asm/traps.h>
\r
2343 +#include <asm/ifx/ifx_types.h>
\r
2344 +#include <asm/ifx/ifx_regs.h>
\r
2345 +#include <asm/ifx/common_routines.h>
\r
2346 +#include <asm/ifx/irq.h>
\r
2348 +#include "ifxmips_pcie_reg.h"
\r
2349 +#include "ifxmips_pcie.h"
\r
2351 +#define IFX_MSI_IRQ_NUM 16
\r
2354 + IFX_PCIE_MSI_IDX0 = 0,
\r
2355 + IFX_PCIE_MSI_IDX1,
\r
2356 + IFX_PCIE_MSI_IDX2,
\r
2357 + IFX_PCIE_MSI_IDX3,
\r
2360 +typedef struct ifx_msi_irq_idx {
\r
2363 +}ifx_msi_irq_idx_t;
\r
2365 +struct ifx_msi_pic {
\r
2366 + volatile u32 pic_table[IFX_MSI_IRQ_NUM];
\r
2367 + volatile u32 pic_endian; /* 0x40 */
\r
2369 +typedef struct ifx_msi_pic *ifx_msi_pic_t;
\r
2371 +typedef struct ifx_msi_irq {
\r
2372 + const volatile ifx_msi_pic_t msi_pic_p;
\r
2373 + const u32 msi_phy_base;
\r
2374 + const ifx_msi_irq_idx_t msi_irq_idx[IFX_MSI_IRQ_NUM];
\r
2376 + * Each bit in msi_free_irq_bitmask represents a MSI interrupt that is
\r
2379 + u16 msi_free_irq_bitmask;
\r
2382 + * Each bit in msi_multiple_irq_bitmask tells that the device using
\r
2383 + * this bit in msi_free_irq_bitmask is also using the next bit. This
\r
2384 + * is used so we can disable all of the MSI interrupts when a device
\r
2385 + * uses multiple.
\r
2387 + u16 msi_multiple_irq_bitmask;
\r
2390 +static ifx_msi_irq_t msi_irqs[IFX_PCIE_CORE_NR] = {
\r
2392 + .msi_pic_p = (const volatile ifx_msi_pic_t)IFX_MSI_PIC_REG_BASE,
\r
2393 + .msi_phy_base = PCIE_MSI_PHY_BASE,
\r
2394 + .msi_irq_idx = {
\r
2395 + {IFX_PCIE_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE_MSI_IR1, IFX_PCIE_MSI_IDX1},
\r
2396 + {IFX_PCIE_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE_MSI_IR3, IFX_PCIE_MSI_IDX3},
\r
2397 + {IFX_PCIE_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE_MSI_IR1, IFX_PCIE_MSI_IDX1},
\r
2398 + {IFX_PCIE_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE_MSI_IR3, IFX_PCIE_MSI_IDX3},
\r
2399 + {IFX_PCIE_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE_MSI_IR1, IFX_PCIE_MSI_IDX1},
\r
2400 + {IFX_PCIE_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE_MSI_IR3, IFX_PCIE_MSI_IDX3},
\r
2401 + {IFX_PCIE_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE_MSI_IR1, IFX_PCIE_MSI_IDX1},
\r
2402 + {IFX_PCIE_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE_MSI_IR3, IFX_PCIE_MSI_IDX3},
\r
2404 + .msi_free_irq_bitmask = 0,
\r
2405 + .msi_multiple_irq_bitmask= 0,
\r
2407 +#ifdef CONFIG_IFX_PCIE_2ND_CORE
\r
2409 + .msi_pic_p = (const volatile ifx_msi_pic_t)IFX_MSI1_PIC_REG_BASE,
\r
2410 + .msi_phy_base = PCIE1_MSI_PHY_BASE,
\r
2411 + .msi_irq_idx = {
\r
2412 + {IFX_PCIE1_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE1_MSI_IR1, IFX_PCIE_MSI_IDX1},
\r
2413 + {IFX_PCIE1_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE1_MSI_IR3, IFX_PCIE_MSI_IDX3},
\r
2414 + {IFX_PCIE1_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE1_MSI_IR1, IFX_PCIE_MSI_IDX1},
\r
2415 + {IFX_PCIE1_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE1_MSI_IR3, IFX_PCIE_MSI_IDX3},
\r
2416 + {IFX_PCIE1_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE1_MSI_IR1, IFX_PCIE_MSI_IDX1},
\r
2417 + {IFX_PCIE1_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE1_MSI_IR3, IFX_PCIE_MSI_IDX3},
\r
2418 + {IFX_PCIE1_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE1_MSI_IR1, IFX_PCIE_MSI_IDX1},
\r
2419 + {IFX_PCIE1_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE1_MSI_IR3, IFX_PCIE_MSI_IDX3},
\r
2421 + .msi_free_irq_bitmask = 0,
\r
2422 + .msi_multiple_irq_bitmask= 0,
\r
2425 +#endif /* CONFIG_IFX_PCIE_2ND_CORE */
\r
2429 + * This lock controls updates to msi_free_irq_bitmask,
\r
2430 + * msi_multiple_irq_bitmask and pic register settting
\r
2432 +static DEFINE_SPINLOCK(ifx_pcie_msi_lock);
\r
2434 +void pcie_msi_pic_init(int pcie_port)
\r
2436 + spin_lock(&ifx_pcie_msi_lock);
\r
2437 + msi_irqs[pcie_port].msi_pic_p->pic_endian = IFX_MSI_PIC_BIG_ENDIAN;
\r
2438 + spin_unlock(&ifx_pcie_msi_lock);
\r
2442 + * \fn int arch_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
\r
2443 + * \brief Called when a driver request MSI interrupts instead of the
\r
2444 + * legacy INT A-D. This routine will allocate multiple interrupts
\r
2445 + * for MSI devices that support them. A device can override this by
\r
2446 + * programming the MSI control bits [6:4] before calling
\r
2447 + * pci_enable_msi().
\r
2449 + * \param[in] pdev Device requesting MSI interrupts
\r
2450 + * \param[in] desc MSI descriptor
\r
2452 + * \return -EINVAL Invalid pcie root port or invalid msi bit
\r
2454 + * \ingroup IFX_PCIE_MSI
\r
2457 +arch_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
\r
2463 + int configured_private_bits;
\r
2464 + int request_private_bits;
\r
2465 + struct msi_msg msg;
\r
2466 + u16 search_mask;
\r
2467 + struct ifx_pci_controller *ctrl = pdev->bus->sysdata;
\r
2468 + int pcie_port = ctrl->port;
\r
2470 + IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s %s enter\n", __func__, pci_name(pdev));
\r
2472 + /* XXX, skip RC MSI itself */
\r
2473 + if (pdev->pcie_type == PCI_EXP_TYPE_ROOT_PORT) {
\r
2474 + IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s RC itself doesn't use MSI interrupt\n", __func__);
\r
2479 + * Read the MSI config to figure out how many IRQs this device
\r
2480 + * wants. Most devices only want 1, which will give
\r
2481 + * configured_private_bits and request_private_bits equal 0.
\r
2483 + pci_read_config_word(pdev, desc->msi_attrib.pos + PCI_MSI_FLAGS, &control);
\r
2486 + * If the number of private bits has been configured then use
\r
2487 + * that value instead of the requested number. This gives the
\r
2488 + * driver the chance to override the number of interrupts
\r
2489 + * before calling pci_enable_msi().
\r
2491 + configured_private_bits = (control & PCI_MSI_FLAGS_QSIZE) >> 4;
\r
2492 + if (configured_private_bits == 0) {
\r
2493 + /* Nothing is configured, so use the hardware requested size */
\r
2494 + request_private_bits = (control & PCI_MSI_FLAGS_QMASK) >> 1;
\r
2498 + * Use the number of configured bits, assuming the
\r
2499 + * driver wanted to override the hardware request
\r
2502 + request_private_bits = configured_private_bits;
\r
2506 + * The PCI 2.3 spec mandates that there are at most 32
\r
2507 + * interrupts. If this device asks for more, only give it one.
\r
2509 + if (request_private_bits > 5) {
\r
2510 + request_private_bits = 0;
\r
2514 + * The IRQs have to be aligned on a power of two based on the
\r
2515 + * number being requested.
\r
2517 + irq_step = (1 << request_private_bits);
\r
2519 + /* Mask with one bit for each IRQ */
\r
2520 + search_mask = (1 << irq_step) - 1;
\r
2523 + * We're going to search msi_free_irq_bitmask_lock for zero
\r
2524 + * bits. This represents an MSI interrupt number that isn't in
\r
2527 + spin_lock(&ifx_pcie_msi_lock);
\r
2528 + for (pos = 0; pos < IFX_MSI_IRQ_NUM; pos += irq_step) {
\r
2529 + if ((msi_irqs[pcie_port].msi_free_irq_bitmask & (search_mask << pos)) == 0) {
\r
2530 + msi_irqs[pcie_port].msi_free_irq_bitmask |= search_mask << pos;
\r
2531 + msi_irqs[pcie_port].msi_multiple_irq_bitmask |= (search_mask >> 1) << pos;
\r
2535 + spin_unlock(&ifx_pcie_msi_lock);
\r
2537 + /* Make sure the search for available interrupts didn't fail */
\r
2538 + if (pos >= IFX_MSI_IRQ_NUM) {
\r
2539 + if (request_private_bits) {
\r
2540 + IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s: Unable to find %d free "
\r
2541 + "interrupts, trying just one", __func__, 1 << request_private_bits);
\r
2542 + request_private_bits = 0;
\r
2546 + printk(KERN_ERR "%s: Unable to find a free MSI interrupt\n", __func__);
\r
2550 + irq = msi_irqs[pcie_port].msi_irq_idx[pos].irq;
\r
2551 + irq_idx = msi_irqs[pcie_port].msi_irq_idx[pos].idx;
\r
2553 + IFX_PCIE_PRINT(PCIE_MSG_MSI, "pos %d, irq %d irq_idx %d\n", pos, irq, irq_idx);
\r
2556 + * Initialize MSI. This has to match the memory-write endianess from the device
\r
2557 + * Address bits [23:12]
\r
2559 + spin_lock(&ifx_pcie_msi_lock);
\r
2560 + msi_irqs[pcie_port].msi_pic_p->pic_table[pos] = SM(irq_idx, IFX_MSI_PIC_INT_LINE) |
\r
2561 + SM((msi_irqs[pcie_port].msi_phy_base >> 12), IFX_MSI_PIC_MSG_ADDR) |
\r
2562 + SM((1 << pos), IFX_MSI_PIC_MSG_DATA);
\r
2564 + /* Enable this entry */
\r
2565 + msi_irqs[pcie_port].msi_pic_p->pic_table[pos] &= ~IFX_MSI_PCI_INT_DISABLE;
\r
2566 + spin_unlock(&ifx_pcie_msi_lock);
\r
2568 + IFX_PCIE_PRINT(PCIE_MSG_MSI, "pic_table[%d]: 0x%08x\n",
\r
2569 + pos, msi_irqs[pcie_port].msi_pic_p->pic_table[pos]);
\r
2571 + /* Update the number of IRQs the device has available to it */
\r
2572 + control &= ~PCI_MSI_FLAGS_QSIZE;
\r
2573 + control |= (request_private_bits << 4);
\r
2574 + pci_write_config_word(pdev, desc->msi_attrib.pos + PCI_MSI_FLAGS, control);
\r
2576 + set_irq_msi(irq, desc);
\r
2577 + msg.address_hi = 0x0;
\r
2578 + msg.address_lo = msi_irqs[pcie_port].msi_phy_base;
\r
2579 + msg.data = SM((1 << pos), IFX_MSI_PIC_MSG_DATA);
\r
2580 + IFX_PCIE_PRINT(PCIE_MSG_MSI, "msi_data: pos %d 0x%08x\n", pos, msg.data);
\r
2582 + write_msi_msg(irq, &msg);
\r
2583 + IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s exit\n", __func__);
\r
2588 +pcie_msi_irq_to_port(unsigned int irq, int *port)
\r
2592 + if (irq == IFX_PCIE_MSI_IR0 || irq == IFX_PCIE_MSI_IR1 ||
\r
2593 + irq == IFX_PCIE_MSI_IR2 || irq == IFX_PCIE_MSI_IR3) {
\r
2594 + *port = IFX_PCIE_PORT0;
\r
2596 +#ifdef CONFIG_IFX_PCIE_2ND_CORE
\r
2597 + else if (irq == IFX_PCIE1_MSI_IR0 || irq == IFX_PCIE1_MSI_IR1 ||
\r
2598 + irq == IFX_PCIE1_MSI_IR2 || irq == IFX_PCIE1_MSI_IR3) {
\r
2599 + *port = IFX_PCIE_PORT1;
\r
2601 +#endif /* CONFIG_IFX_PCIE_2ND_CORE */
\r
2603 + printk(KERN_ERR "%s: Attempted to teardown illegal "
\r
2604 + "MSI interrupt (%d)\n", __func__, irq);
\r
2611 + * \fn void arch_teardown_msi_irq(unsigned int irq)
\r
2612 + * \brief Called when a device no longer needs its MSI interrupts. All
\r
2613 + * MSI interrupts for the device are freed.
\r
2615 + * \param irq The devices first irq number. There may be multple in sequence.
\r
2617 + * \ingroup IFX_PCIE_MSI
\r
2620 +arch_teardown_msi_irq(unsigned int irq)
\r
2623 + int number_irqs;
\r
2627 + IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s enter\n", __func__);
\r
2629 + BUG_ON(irq > INT_NUM_IM4_IRL31);
\r
2631 + if (pcie_msi_irq_to_port(irq, &pcie_port) != 0) {
\r
2635 + /* Shift the mask to the correct bit location, not always correct
\r
2636 + * Probally, the first match will be chosen.
\r
2638 + for (pos = 0; pos < IFX_MSI_IRQ_NUM; pos++) {
\r
2639 + if ((msi_irqs[pcie_port].msi_irq_idx[pos].irq == irq)
\r
2640 + && (msi_irqs[pcie_port].msi_free_irq_bitmask & ( 1 << pos))) {
\r
2644 + if (pos >= IFX_MSI_IRQ_NUM) {
\r
2645 + printk(KERN_ERR "%s: Unable to find a matched MSI interrupt\n", __func__);
\r
2648 + spin_lock(&ifx_pcie_msi_lock);
\r
2649 + /* Disable this entry */
\r
2650 + msi_irqs[pcie_port].msi_pic_p->pic_table[pos] |= IFX_MSI_PCI_INT_DISABLE;
\r
2651 + 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);
\r
2652 + spin_unlock(&ifx_pcie_msi_lock);
\r
2654 + * Count the number of IRQs we need to free by looking at the
\r
2655 + * msi_multiple_irq_bitmask. Each bit set means that the next
\r
2656 + * IRQ is also owned by this device.
\r
2658 + number_irqs = 0;
\r
2659 + while (((pos + number_irqs) < IFX_MSI_IRQ_NUM) &&
\r
2660 + (msi_irqs[pcie_port].msi_multiple_irq_bitmask & (1 << (pos + number_irqs)))) {
\r
2665 + /* Mask with one bit for each IRQ */
\r
2666 + bitmask = (1 << number_irqs) - 1;
\r
2668 + bitmask <<= pos;
\r
2669 + if ((msi_irqs[pcie_port].msi_free_irq_bitmask & bitmask) != bitmask) {
\r
2670 + printk(KERN_ERR "%s: Attempted to teardown MSI "
\r
2671 + "interrupt (%d) not in use\n", __func__, irq);
\r
2674 + /* Checks are done, update the in use bitmask */
\r
2675 + spin_lock(&ifx_pcie_msi_lock);
\r
2676 + msi_irqs[pcie_port].msi_free_irq_bitmask &= ~bitmask;
\r
2677 + msi_irqs[pcie_port].msi_multiple_irq_bitmask &= ~(bitmask >> 1);
\r
2678 + spin_unlock(&ifx_pcie_msi_lock);
\r
2679 + IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s exit\n", __func__);
\r
2682 +MODULE_LICENSE("GPL");
\r
2683 +MODULE_AUTHOR("Chuanhua.Lei@infineon.com");
\r
2684 +MODULE_SUPPORTED_DEVICE("Infineon PCIe IP builtin MSI PIC module");
\r
2685 +MODULE_DESCRIPTION("Infineon PCIe IP builtin MSI PIC driver");
\r
2688 +++ b/arch/mips/pci/ifxmips_pcie_phy.c
2690 +/******************************************************************************
\r
2692 +** FILE NAME : ifxmips_pcie_phy.c
2693 +** PROJECT : IFX UEIP for VRX200
2694 +** MODULES : PCIe PHY sub module
2696 +** DATE : 14 May 2009
2697 +** AUTHOR : Lei Chuanhua
2698 +** DESCRIPTION : PCIe Root Complex Driver
2699 +** COPYRIGHT : Copyright (c) 2009
2700 +** Infineon Technologies AG
2701 +** Am Campeon 1-12, 85579 Neubiberg, Germany
2703 +** This program is free software; you can redistribute it and/or modify
2704 +** it under the terms of the GNU General Public License as published by
2705 +** the Free Software Foundation; either version 2 of the License, or
2706 +** (at your option) any later version.
2708 +** $Version $Date $Author $Comment
2709 +** 0.0.1 14 May,2009 Lei Chuanhua Initial version
2710 +*******************************************************************************/
2712 + \file ifxmips_pcie_phy.c
\r
2713 + \ingroup IFX_PCIE
\r
2714 + \brief PCIe PHY PLL register programming source file
\r
2716 +#include <linux/types.h>
2717 +#include <linux/kernel.h>
2718 +#include <asm/paccess.h>
2719 +#include <linux/delay.h>
\r
2721 +#include "ifxmips_pcie_reg.h"
2722 +#include "ifxmips_pcie.h"
2724 +/* PCIe PDI only supports 16 bit operation */
2726 +#define IFX_PCIE_PHY_REG_WRITE16(__addr, __data) \
2727 + ((*(volatile u16 *) (__addr)) = (__data))
2729 +#define IFX_PCIE_PHY_REG_READ16(__addr) \
2730 + (*(volatile u16 *) (__addr))
2732 +#define IFX_PCIE_PHY_REG16(__addr) \
2733 + (*(volatile u16 *) (__addr))
2735 +#define IFX_PCIE_PHY_REG(__reg, __value, __mask) do { \
\r
2736 + u16 read_data; \
\r
2737 + u16 write_data; \
\r
2738 + read_data = IFX_PCIE_PHY_REG_READ16((__reg)); \
\r
2739 + write_data = (read_data & ((u16)~(__mask))) | (((u16)(__value)) & ((u16)(__mask)));\
\r
2740 + IFX_PCIE_PHY_REG_WRITE16((__reg), write_data); \
\r
2743 +#define IFX_PCIE_PLL_TIMEOUT 1000 /* Tunnable */
\r
2745 +//#define IFX_PCI_PHY_REG_DUMP
2747 +#ifdef IFX_PCI_PHY_REG_DUMP
2749 +pcie_phy_reg_dump(int pcie_port)
2751 + printk("PLL REGFILE\n");
2752 + printk("PCIE_PHY_PLL_CTRL1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_CTRL1(pcie_port)));
2753 + printk("PCIE_PHY_PLL_CTRL2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_CTRL2(pcie_port)));
2754 + printk("PCIE_PHY_PLL_CTRL3 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_CTRL3(pcie_port)));
2755 + printk("PCIE_PHY_PLL_CTRL4 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_CTRL4(pcie_port)));
2756 + printk("PCIE_PHY_PLL_CTRL5 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_CTRL5(pcie_port)));
2757 + printk("PCIE_PHY_PLL_CTRL6 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_CTRL6(pcie_port)));
2758 + printk("PCIE_PHY_PLL_CTRL7 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_CTRL7(pcie_port)));
2759 + printk("PCIE_PHY_PLL_A_CTRL1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_A_CTRL1(pcie_port)));
2760 + printk("PCIE_PHY_PLL_A_CTRL2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_A_CTRL2(pcie_port)));
2761 + printk("PCIE_PHY_PLL_A_CTRL3 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_A_CTRL3(pcie_port)));
2762 + printk("PCIE_PHY_PLL_STATUS 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_STATUS(pcie_port)));
2764 + printk("TX1 REGFILE\n");
2765 + printk("PCIE_PHY_TX1_CTRL1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_CTRL1(pcie_port)));
2766 + printk("PCIE_PHY_TX1_CTRL2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_CTRL2(pcie_port)));
2767 + printk("PCIE_PHY_TX1_CTRL3 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_CTRL3(pcie_port)));
2768 + printk("PCIE_PHY_TX1_A_CTRL1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_A_CTRL1(pcie_port)));
2769 + printk("PCIE_PHY_TX1_A_CTRL2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_A_CTRL2(pcie_port)));
2770 + printk("PCIE_PHY_TX1_MOD1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_MOD1(pcie_port)));
\r
2771 + printk("PCIE_PHY_TX1_MOD2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_MOD2(pcie_port)));
\r
2772 + printk("PCIE_PHY_TX1_MOD3 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX1_MOD3(pcie_port)));
\r
2774 + printk("TX2 REGFILE\n");
2775 + printk("PCIE_PHY_TX2_CTRL1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX2_CTRL1(pcie_port)));
\r
2776 + printk("PCIE_PHY_TX2_CTRL2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX2_CTRL2(pcie_port)));
2777 + printk("PCIE_PHY_TX2_A_CTRL1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX2_A_CTRL1(pcie_port)));
2778 + printk("PCIE_PHY_TX2_A_CTRL2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX2_A_CTRL2(pcie_port)));
2779 + printk("PCIE_PHY_TX2_MOD1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX2_MOD1(pcie_port)));
\r
2780 + printk("PCIE_PHY_TX2_MOD2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX2_MOD2(pcie_port)));
\r
2781 + printk("PCIE_PHY_TX2_MOD3 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_TX2_MOD3(pcie_port)));
\r
2783 + printk("RX1 REGFILE\n");
2784 + printk("PCIE_PHY_RX1_CTRL1 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_RX1_CTRL1(pcie_port)));
2785 + printk("PCIE_PHY_RX1_CTRL2 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_RX1_CTRL2(pcie_port)));
\r
2786 + printk("PCIE_PHY_RX1_CDR 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_RX1_CDR(pcie_port)));
2787 + printk("PCIE_PHY_RX1_EI 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_RX1_EI(pcie_port)));
2788 + printk("PCIE_PHY_RX1_A_CTRL 0x%04x\n", IFX_PCIE_PHY_REG16(PCIE_PHY_RX1_A_CTRL(pcie_port)));
\r
2790 +#endif /* IFX_PCI_PHY_REG_DUMP */
2793 +pcie_phy_comm_setup(int pcie_port)
2796 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL1(pcie_port), 0x120e, 0xFFFF);
2798 + /* increase the bias reference voltage */
2799 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x39D7, 0xFFFF);
2800 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x0900, 0xFFFF);
2803 + IFX_PCIE_PHY_REG(PCIE_PHY_RX1_EI(pcie_port), 0x0004, 0xFFFF);
2804 + IFX_PCIE_PHY_REG(PCIE_PHY_RX1_A_CTRL(pcie_port), 0x6803, 0xFFFF);
2807 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL1(pcie_port), 0x0008, 0x0008);
\r
2809 + /* predrv_ser_en */
\r
2810 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_A_CTRL2(pcie_port), 0x0706, 0xFFFF);
\r
2813 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL3(pcie_port), 0x1FFF, 0xFFFF);
2816 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_A_CTRL1(pcie_port), 0x0800, 0xFF00);
2818 + /* predrv_ser_en */
2819 + IFX_PCIE_PHY_REG(PCIE_PHY_TX2_A_CTRL2(pcie_port), 0x4702, 0x7F00);
2822 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL2(pcie_port), 0x2e00, 0xFFFF);
2824 + /* Improved 100MHz clock output */
\r
2825 + IFX_PCIE_PHY_REG(PCIE_PHY_TX2_CTRL2(pcie_port), 0x3096, 0xFFFF);
\r
2826 + IFX_PCIE_PHY_REG(PCIE_PHY_TX2_A_CTRL2(pcie_port), 0x4707, 0xFFFF);
\r
2828 + /* Reduced CDR BW to avoid glitches */
\r
2829 + IFX_PCIE_PHY_REG(PCIE_PHY_RX1_CDR(pcie_port), 0x0235, 0xFFFF);
\r
2832 +#ifdef CONFIG_IFX_PCIE_PHY_36MHZ_MODE
\r
2834 +pcie_phy_36mhz_mode_setup(int pcie_port)
\r
2836 + IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d enter\n", __func__, pcie_port);
\r
2837 +#ifdef IFX_PCI_PHY_REG_DUMP
\r
2838 + IFX_PCIE_PRINT(PCIE_MSG_PHY, "Initial PHY register dump\n");
\r
2839 + pcie_phy_reg_dump(pcie_port);
\r
2842 + /* en_ext_mmd_div_ratio */
2843 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0002);
2845 + /* ext_mmd_div_ratio*/
2846 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0070);
2849 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0200, 0x0200);
2851 + /* en_const_sdm */
2852 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0100, 0x0100);
2855 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x2000, 0xe000);
\r
2858 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x0000, 0x4000);
2861 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL1(pcie_port), 0x38e4, 0xFFFF);
2864 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x00ee, 0x00FF);
2867 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL7(pcie_port), 0x0002, 0xFFFF);
2868 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL6(pcie_port), 0x3a04, 0xFFFF);
2869 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL5(pcie_port), 0xfae3, 0xFFFF);
2870 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL4(pcie_port), 0x1b72, 0xFFFF);
2872 + IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d exit\n", __func__, pcie_port);
2874 +#endif /* CONFIG_IFX_PCIE_PHY_36MHZ_MODE */
2876 +#ifdef CONFIG_IFX_PCIE_PHY_36MHZ_SSC_MODE
\r
2878 +pcie_phy_36mhz_ssc_mode_setup(int pcie_port)
\r
2880 + IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d enter\n", __func__, pcie_port);
\r
2881 +#ifdef IFX_PCI_PHY_REG_DUMP
\r
2882 + IFX_PCIE_PRINT(PCIE_MSG_PHY, "Initial PHY register dump\n");
\r
2883 + pcie_phy_reg_dump(pcie_port);
\r
2886 + /* PLL Setting */
\r
2887 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL1(pcie_port), 0x120e, 0xFFFF);
\r
2889 + /* Increase the bias reference voltage */
\r
2890 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x39D7, 0xFFFF);
\r
2891 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x0900, 0xFFFF);
\r
2894 + IFX_PCIE_PHY_REG(PCIE_PHY_RX1_EI(pcie_port), 0x0004, 0xFFFF);
\r
2895 + IFX_PCIE_PHY_REG(PCIE_PHY_RX1_A_CTRL(pcie_port), 0x6803, 0xFFFF);
\r
2898 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL1(pcie_port), 0x0008, 0x0008);
\r
2900 + /* Predrv_ser_en */
\r
2901 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_A_CTRL2(pcie_port), 0x0706, 0xFFFF);
\r
2904 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL3(pcie_port), 0x1FFF, 0xFFFF);
\r
2907 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_A_CTRL1(pcie_port), 0x0800, 0xFF00);
\r
2909 + /* predrv_ser_en */
\r
2910 + IFX_PCIE_PHY_REG(PCIE_PHY_TX2_A_CTRL2(pcie_port), 0x4702, 0x7F00);
\r
2913 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL2(pcie_port), 0x2e00, 0xFFFF);
\r
2915 + /* en_ext_mmd_div_ratio */
\r
2916 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0002);
\r
2918 + /* ext_mmd_div_ratio*/
\r
2919 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0070);
\r
2922 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0400, 0x0400);
\r
2924 + /* en_const_sdm */
\r
2925 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0200, 0x0200);
\r
2928 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x2000, 0xe000);
\r
2931 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x0000, 0x4000);
\r
2934 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL1(pcie_port), 0x38e4, 0xFFFF);
\r
2936 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0000, 0x0100);
\r
2938 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x00ee, 0x00FF);
\r
2941 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL7(pcie_port), 0x0002, 0xFFFF);
\r
2942 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL6(pcie_port), 0x3a04, 0xFFFF);
\r
2943 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL5(pcie_port), 0xfae3, 0xFFFF);
\r
2944 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL4(pcie_port), 0x1c72, 0xFFFF);
\r
2946 + /* improved 100MHz clock output */
\r
2947 + IFX_PCIE_PHY_REG(PCIE_PHY_TX2_CTRL2(pcie_port), 0x3096, 0xFFFF);
\r
2948 + IFX_PCIE_PHY_REG(PCIE_PHY_TX2_A_CTRL2(pcie_port), 0x4707, 0xFFFF);
\r
2950 + /* reduced CDR BW to avoid glitches */
\r
2951 + IFX_PCIE_PHY_REG(PCIE_PHY_RX1_CDR(pcie_port), 0x0235, 0xFFFF);
\r
2953 + IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d exit\n", __func__, pcie_port);
\r
2955 +#endif /* CONFIG_IFX_PCIE_PHY_36MHZ_SSC_MODE */
\r
2957 +#ifdef CONFIG_IFX_PCIE_PHY_25MHZ_MODE
2959 +pcie_phy_25mhz_mode_setup(int pcie_port)
2961 + IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d enter\n", __func__, pcie_port);
2962 +#ifdef IFX_PCI_PHY_REG_DUMP
2963 + IFX_PCIE_PRINT(PCIE_MSG_PHY, "Initial PHY register dump\n");
2964 + pcie_phy_reg_dump(pcie_port);
2966 + /* en_const_sdm */
\r
2967 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0100, 0x0100);
\r
2970 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0000, 0x0200);
2972 + /* en_ext_mmd_div_ratio*/
2973 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0002, 0x0002);
2975 + /* ext_mmd_div_ratio*/
2976 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0040, 0x0070);
2979 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x6000, 0xe000);
2982 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x4000, 0x4000);
2984 + IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d exit\n", __func__, pcie_port);
\r
2986 +#endif /* CONFIG_IFX_PCIE_PHY_25MHZ_MODE */
2988 +#ifdef CONFIG_IFX_PCIE_PHY_100MHZ_MODE
\r
2990 +pcie_phy_100mhz_mode_setup(int pcie_port)
2992 + IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d enter\n", __func__, pcie_port);
2993 +#ifdef IFX_PCI_PHY_REG_DUMP
2994 + IFX_PCIE_PRINT(PCIE_MSG_PHY, "Initial PHY register dump\n");
\r
2995 + pcie_phy_reg_dump(pcie_port);
\r
2997 + /* en_ext_mmd_div_ratio */
2998 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0002);
3000 + /* ext_mmd_div_ratio*/
3001 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0070);
3004 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0200, 0x0200);
3006 + /* en_const_sdm */
3007 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0100, 0x0100);
3010 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x2000, 0xe000);
3013 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x0000, 0x4000);
3016 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL1(pcie_port), 0x38e4, 0xFFFF);
3019 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x00ee, 0x00FF);
3022 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL7(pcie_port), 0x0002, 0xFFFF);
3023 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL6(pcie_port), 0x3a04, 0xFFFF);
3024 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL5(pcie_port), 0xfae3, 0xFFFF);
3025 + IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL4(pcie_port), 0x1b72, 0xFFFF);
3027 + IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d exit\n", __func__, pcie_port);
3029 +#endif /* CONFIG_IFX_PCIE_PHY_100MHZ_MODE */
3032 +pcie_phy_wait_startup_ready(int pcie_port)
\r
3036 + for (i = 0; i < IFX_PCIE_PLL_TIMEOUT; i++) {
\r
3037 + if ((IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_STATUS(pcie_port)) & 0x0040) != 0) {
\r
3042 + if (i >= IFX_PCIE_PLL_TIMEOUT) {
\r
3043 + printk(KERN_ERR "%s PLL Link timeout\n", __func__);
\r
3050 +pcie_phy_load_enable(int pcie_port, int slice)
\r
3052 + /* Set the load_en of tx/rx slice to '1' */
\r
3053 + switch (slice) {
\r
3055 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL1(pcie_port), 0x0010, 0x0010);
\r
3058 + IFX_PCIE_PHY_REG(PCIE_PHY_TX2_CTRL1(pcie_port), 0x0010, 0x0010);
\r
3061 + IFX_PCIE_PHY_REG(PCIE_PHY_RX1_CTRL1(pcie_port), 0x0002, 0x0002);
\r
3067 +pcie_phy_load_disable(int pcie_port, int slice)
\r
3069 + /* set the load_en of tx/rx slice to '0' */
\r
3070 + switch (slice) {
\r
3072 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL1(pcie_port), 0x0000, 0x0010);
\r
3075 + IFX_PCIE_PHY_REG(PCIE_PHY_TX2_CTRL1(pcie_port), 0x0000, 0x0010);
\r
3078 + IFX_PCIE_PHY_REG(PCIE_PHY_RX1_CTRL1(pcie_port), 0x0000, 0x0002);
\r
3084 +pcie_phy_load_war(int pcie_port)
\r
3088 + for (slice = 1; slice < 4; slice++) {
\r
3089 + pcie_phy_load_enable(pcie_port, slice);
\r
3091 + pcie_phy_load_disable(pcie_port, slice);
\r
3096 +pcie_phy_tx2_modulation(int pcie_port)
\r
3098 + IFX_PCIE_PHY_REG(PCIE_PHY_TX2_MOD1(pcie_port), 0x1FFE, 0xFFFF);
\r
3099 + IFX_PCIE_PHY_REG(PCIE_PHY_TX2_MOD2(pcie_port), 0xFFFE, 0xFFFF);
\r
3100 + IFX_PCIE_PHY_REG(PCIE_PHY_TX2_MOD3(pcie_port), 0x0601, 0xFFFF);
\r
3102 + IFX_PCIE_PHY_REG(PCIE_PHY_TX2_MOD3(pcie_port), 0x0001, 0xFFFF);
\r
3106 +pcie_phy_tx1_modulation(int pcie_port)
\r
3108 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_MOD1(pcie_port), 0x1FFE, 0xFFFF);
\r
3109 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_MOD2(pcie_port), 0xFFFE, 0xFFFF);
\r
3110 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_MOD3(pcie_port), 0x0601, 0xFFFF);
\r
3112 + IFX_PCIE_PHY_REG(PCIE_PHY_TX1_MOD3(pcie_port), 0x0001, 0xFFFF);
\r
3116 +pcie_phy_tx_modulation_war(int pcie_port)
\r
3120 +#define PCIE_PHY_MODULATION_NUM 5
\r
3121 + for (i = 0; i < PCIE_PHY_MODULATION_NUM; i++) {
\r
3122 + pcie_phy_tx2_modulation(pcie_port);
\r
3123 + pcie_phy_tx1_modulation(pcie_port);
\r
3125 +#undef PCIE_PHY_MODULATION_NUM
\r
3129 +pcie_phy_clock_mode_setup(int pcie_port)
3131 + pcie_pdi_big_endian(pcie_port);
3133 + /* Enable PDI to access PCIe PHY register */
3134 + pcie_pdi_pmu_enable(pcie_port);
3136 + /* Configure PLL and PHY clock */
\r
3137 + pcie_phy_comm_setup(pcie_port);
\r
3139 +#ifdef CONFIG_IFX_PCIE_PHY_36MHZ_MODE
3140 + pcie_phy_36mhz_mode_setup(pcie_port);
3141 +#elif defined(CONFIG_IFX_PCIE_PHY_36MHZ_SSC_MODE)
\r
3142 + pcie_phy_36mhz_ssc_mode_setup(pcie_port);
\r
3143 +#elif defined(CONFIG_IFX_PCIE_PHY_25MHZ_MODE)
3144 + pcie_phy_25mhz_mode_setup(pcie_port);
3145 +#elif defined (CONFIG_IFX_PCIE_PHY_100MHZ_MODE)
3146 + pcie_phy_100mhz_mode_setup(pcie_port);
3148 + #error "PCIE PHY Clock Mode must be chosen first!!!!"
3149 +#endif /* CONFIG_IFX_PCIE_PHY_36MHZ_MODE */
3151 + /* Enable PCIe PHY and make PLL setting take effect */
\r
3152 + pcie_phy_pmu_enable(pcie_port);
\r
3154 + /* Check if we are in startup_ready status */
\r
3155 + pcie_phy_wait_startup_ready(pcie_port);
\r
3157 + pcie_phy_load_war(pcie_port);
\r
3159 + /* Apply TX modulation workarounds */
\r
3160 + pcie_phy_tx_modulation_war(pcie_port);
\r
3162 +#ifdef IFX_PCI_PHY_REG_DUMP
\r
3163 + IFX_PCIE_PRINT(PCIE_MSG_PHY, "Modified PHY register dump\n");
\r
3164 + pcie_phy_reg_dump(pcie_port);
\r
3169 +++ b/arch/mips/pci/ifxmips_pcie_pm.c
3171 +/******************************************************************************
3173 +** FILE NAME : ifxmips_pcie_pm.c
3174 +** PROJECT : IFX UEIP
3175 +** MODULES : PCIE Root Complex Driver
3177 +** DATE : 21 Dec 2009
3178 +** AUTHOR : Lei Chuanhua
3179 +** DESCRIPTION : PCIE Root Complex Driver Power Managment
3180 +** COPYRIGHT : Copyright (c) 2009
3181 +** Lantiq Deutschland GmbH
3182 +** Am Campeon 3, 85579 Neubiberg, Germany
3184 +** This program is free software; you can redistribute it and/or modify
3185 +** it under the terms of the GNU General Public License as published by
3186 +** the Free Software Foundation; either version 2 of the License, or
3187 +** (at your option) any later version.
3190 +** $Date $Author $Comment
3191 +** 21 Dec,2009 Lei Chuanhua First UEIP release
3192 +*******************************************************************************/
3194 + \defgroup IFX_PCIE_PM Power Management functions
3196 + \brief IFX PCIE Root Complex Driver power management functions
3200 + \file ifxmips_pcie_pm.c
3202 + \brief source file for PCIE Root Complex Driver Power Management
3205 +#ifndef EXPORT_SYMTAB
3206 +#define EXPORT_SYMTAB
3208 +#ifndef AUTOCONF_INCLUDED
3209 +#include <linux/config.h>
3210 +#endif /* AUTOCONF_INCLUDED */
3211 +#include <linux/version.h>
3212 +#include <linux/module.h>
3213 +#include <linux/types.h>
3214 +#include <linux/kernel.h>
3215 +#include <asm/system.h>
3217 +/* Project header */
3218 +#include <asm/ifx/ifx_types.h>
3219 +#include <asm/ifx/ifx_regs.h>
3220 +#include <asm/ifx/common_routines.h>
3221 +#include <asm/ifx/ifx_pmcu.h>
3222 +#include "ifxmips_pcie_pm.h"
3225 + * \fn static IFX_PMCU_RETURN_t ifx_pcie_pmcu_state_change(IFX_PMCU_STATE_t pmcuState)
3226 + * \brief the callback function to request pmcu state in the power management hardware-dependent module
3228 + * \param pmcuState This parameter is a PMCU state.
3230 + * \return IFX_PMCU_RETURN_SUCCESS Set Power State successfully
3231 + * \return IFX_PMCU_RETURN_ERROR Failed to set power state.
3232 + * \return IFX_PMCU_RETURN_DENIED Not allowed to operate power state
3233 + * \ingroup IFX_PCIE_PM
3235 +static IFX_PMCU_RETURN_t
3236 +ifx_pcie_pmcu_state_change(IFX_PMCU_STATE_t pmcuState)
3240 + case IFX_PMCU_STATE_D0:
3241 + return IFX_PMCU_RETURN_SUCCESS;
3242 + case IFX_PMCU_STATE_D1: // Not Applicable
3243 + return IFX_PMCU_RETURN_DENIED;
3244 + case IFX_PMCU_STATE_D2: // Not Applicable
3245 + return IFX_PMCU_RETURN_DENIED;
3246 + case IFX_PMCU_STATE_D3: // Module clock gating and Power gating
3247 + return IFX_PMCU_RETURN_SUCCESS;
3249 + return IFX_PMCU_RETURN_DENIED;
3254 + * \fn static IFX_PMCU_RETURN_t ifx_pcie_pmcu_state_get(IFX_PMCU_STATE_t *pmcuState)
3255 + * \brief the callback function to get pmcu state in the power management hardware-dependent module
3257 + * \param pmcuState Pointer to return power state.
3259 + * \return IFX_PMCU_RETURN_SUCCESS Set Power State successfully
3260 + * \return IFX_PMCU_RETURN_ERROR Failed to set power state.
3261 + * \return IFX_PMCU_RETURN_DENIED Not allowed to operate power state
3262 + * \ingroup IFX_PCIE_PM
3264 +static IFX_PMCU_RETURN_t
3265 +ifx_pcie_pmcu_state_get(IFX_PMCU_STATE_t *pmcuState)
3267 + return IFX_PMCU_RETURN_SUCCESS;
3271 + * \fn IFX_PMCU_RETURN_t ifx_pcie_pmcu_prechange(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
3272 + * \brief Apply all callbacks registered to be executed before a state change for pmcuModule
3274 + * \param pmcuModule Module
3275 + * \param newState New state
3276 + * \param oldState Old state
3277 + * \return IFX_PMCU_RETURN_SUCCESS Set Power State successfully
3278 + * \return IFX_PMCU_RETURN_ERROR Failed to set power state.
3279 + * \ingroup IFX_PCIE_PM
3281 +static IFX_PMCU_RETURN_t
3282 +ifx_pcie_pmcu_prechange(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
3284 + return IFX_PMCU_RETURN_SUCCESS;
3288 + * \fn IFX_PMCU_RETURN_t ifx_pcie_pmcu_postchange(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
3289 + * \brief Apply all callbacks registered to be executed before a state change for pmcuModule
3291 + * \param pmcuModule Module
3292 + * \param newState New state
3293 + * \param oldState Old state
3294 + * \return IFX_PMCU_RETURN_SUCCESS Set Power State successfully
3295 + * \return IFX_PMCU_RETURN_ERROR Failed to set power state.
3296 + * \ingroup IFX_PCIE_PM
3298 +static IFX_PMCU_RETURN_t
3299 +ifx_pcie_pmcu_postchange(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
3301 + return IFX_PMCU_RETURN_SUCCESS;
3305 + * \fn static void ifx_pcie_pmcu_init(void)
3306 + * \brief Register with central PMCU module
3308 + * \ingroup IFX_PCIE_PM
3311 +ifx_pcie_pmcu_init(void)
3313 + IFX_PMCU_REGISTER_t pmcuRegister;
3315 + /* XXX, hook driver context */
3317 + /* State function register */
3318 + memset(&pmcuRegister, 0, sizeof(IFX_PMCU_REGISTER_t));
3319 + pmcuRegister.pmcuModule = IFX_PMCU_MODULE_PCIE;
3320 + pmcuRegister.pmcuModuleNr = 0;
3321 + pmcuRegister.ifx_pmcu_state_change = ifx_pcie_pmcu_state_change;
3322 + pmcuRegister.ifx_pmcu_state_get = ifx_pcie_pmcu_state_get;
3323 + pmcuRegister.pre = ifx_pcie_pmcu_prechange;
3324 + pmcuRegister.post= ifx_pcie_pmcu_postchange;
3325 + ifx_pmcu_register(&pmcuRegister);
3329 + * \fn static void ifx_pcie_pmcu_exit(void)
3330 + * \brief Unregister with central PMCU module
3333 + * \ingroup IFX_PCIE_PM
3336 +ifx_pcie_pmcu_exit(void)
3338 + IFX_PMCU_REGISTER_t pmcuUnRegister;
3340 + /* XXX, hook driver context */
3342 + pmcuUnRegister.pmcuModule = IFX_PMCU_MODULE_PCIE;
3343 + pmcuUnRegister.pmcuModuleNr = 0;
3344 + ifx_pmcu_unregister(&pmcuUnRegister);
3348 +++ b/arch/mips/pci/ifxmips_pcie_pm.h
3350 +/******************************************************************************
3352 +** FILE NAME : ifxmips_pcie_pm.h
3353 +** PROJECT : IFX UEIP
3354 +** MODULES : PCIe Root Complex Driver
3356 +** DATE : 21 Dec 2009
3357 +** AUTHOR : Lei Chuanhua
3358 +** DESCRIPTION : PCIe Root Complex Driver Power Managment
3359 +** COPYRIGHT : Copyright (c) 2009
3360 +** Lantiq Deutschland GmbH
3361 +** Am Campeon 3, 85579 Neubiberg, Germany
3363 +** This program is free software; you can redistribute it and/or modify
3364 +** it under the terms of the GNU General Public License as published by
3365 +** the Free Software Foundation; either version 2 of the License, or
3366 +** (at your option) any later version.
3369 +** $Date $Author $Comment
3370 +** 21 Dec,2009 Lei Chuanhua First UEIP release
3371 +*******************************************************************************/
3373 + \file ifxmips_pcie_pm.h
3375 + \brief header file for PCIe Root Complex Driver Power Management
3378 +#ifndef IFXMIPS_PCIE_PM_H
3379 +#define IFXMIPS_PCIE_PM_H
3381 +void ifx_pcie_pmcu_init(void);
3382 +void ifx_pcie_pmcu_exit(void);
3384 +#endif /* IFXMIPS_PCIE_PM_H */
3387 +++ b/arch/mips/pci/ifxmips_pcie_reg.h
3389 +/******************************************************************************
3391 +** FILE NAME : ifxmips_pcie_reg.h
3392 +** PROJECT : IFX UEIP for VRX200
3393 +** MODULES : PCIe module
3395 +** DATE : 02 Mar 2009
3396 +** AUTHOR : Lei Chuanhua
3397 +** DESCRIPTION : PCIe Root Complex Driver
3398 +** COPYRIGHT : Copyright (c) 2009
3399 +** Infineon Technologies AG
3400 +** Am Campeon 1-12, 85579 Neubiberg, Germany
3402 +** This program is free software; you can redistribute it and/or modify
3403 +** it under the terms of the GNU General Public License as published by
3404 +** the Free Software Foundation; either version 2 of the License, or
3405 +** (at your option) any later version.
3407 +** $Version $Date $Author $Comment
3408 +** 0.0.1 17 Mar,2009 Lei Chuanhua Initial version
3409 +*******************************************************************************/
3410 +#ifndef IFXMIPS_PCIE_REG_H
3411 +#define IFXMIPS_PCIE_REG_H
3413 + \file ifxmips_pcie_reg.h
3415 + \brief header file for PCIe module register definition
3417 +/* PCIe Address Mapping Base */
3418 +#define PCIE_CFG_PHY_BASE 0x1D000000UL
3419 +#define PCIE_CFG_BASE (KSEG1 + PCIE_CFG_PHY_BASE)
3420 +#define PCIE_CFG_SIZE (8 * 1024 * 1024)
3422 +#define PCIE_MEM_PHY_BASE 0x1C000000UL
3423 +#define PCIE_MEM_BASE (KSEG1 + PCIE_MEM_PHY_BASE)
3424 +#define PCIE_MEM_SIZE (16 * 1024 * 1024)
3425 +#define PCIE_MEM_PHY_END (PCIE_MEM_PHY_BASE + PCIE_MEM_SIZE - 1)
3427 +#define PCIE_IO_PHY_BASE 0x1D800000UL
3428 +#define PCIE_IO_BASE (KSEG1 + PCIE_IO_PHY_BASE)
3429 +#define PCIE_IO_SIZE (1 * 1024 * 1024)
3430 +#define PCIE_IO_PHY_END (PCIE_IO_PHY_BASE + PCIE_IO_SIZE - 1)
3432 +#define PCIE_RC_CFG_BASE (KSEG1 + 0x1D900000)
3433 +#define PCIE_APP_LOGIC_REG (KSEG1 + 0x1E100900)
3434 +#define PCIE_MSI_PHY_BASE 0x1F600000UL
3436 +#define PCIE_PDI_PHY_BASE 0x1F106800UL
3437 +#define PCIE_PDI_BASE (KSEG1 + PCIE_PDI_PHY_BASE)
3438 +#define PCIE_PDI_SIZE 0x400
3440 +#define PCIE1_CFG_PHY_BASE 0x19000000UL
3441 +#define PCIE1_CFG_BASE (KSEG1 + PCIE1_CFG_PHY_BASE)
3442 +#define PCIE1_CFG_SIZE (8 * 1024 * 1024)
3444 +#define PCIE1_MEM_PHY_BASE 0x18000000UL
3445 +#define PCIE1_MEM_BASE (KSEG1 + PCIE1_MEM_PHY_BASE)
3446 +#define PCIE1_MEM_SIZE (16 * 1024 * 1024)
3447 +#define PCIE1_MEM_PHY_END (PCIE1_MEM_PHY_BASE + PCIE1_MEM_SIZE - 1)
3449 +#define PCIE1_IO_PHY_BASE 0x19800000UL
3450 +#define PCIE1_IO_BASE (KSEG1 + PCIE1_IO_PHY_BASE)
3451 +#define PCIE1_IO_SIZE (1 * 1024 * 1024)
3452 +#define PCIE1_IO_PHY_END (PCIE1_IO_PHY_BASE + PCIE1_IO_SIZE - 1)
3454 +#define PCIE1_RC_CFG_BASE (KSEG1 + 0x19900000)
3455 +#define PCIE1_APP_LOGIC_REG (KSEG1 + 0x1E100700)
3456 +#define PCIE1_MSI_PHY_BASE 0x1F400000UL
3458 +#define PCIE1_PDI_PHY_BASE 0x1F700400UL
3459 +#define PCIE1_PDI_BASE (KSEG1 + PCIE1_PDI_PHY_BASE)
3460 +#define PCIE1_PDI_SIZE 0x400
3462 +#define PCIE_CFG_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_CFG_BASE) : (PCIE_CFG_BASE))
3463 +#define PCIE_MEM_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_MEM_BASE) : (PCIE_MEM_BASE))
3464 +#define PCIE_IO_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_IO_BASE) : (PCIE_IO_BASE))
3465 +#define PCIE_MEM_PHY_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_MEM_PHY_BASE) : (PCIE_MEM_PHY_BASE))
3466 +#define PCIE_MEM_PHY_PORT_TO_END(X) ((X) > 0 ? (PCIE1_MEM_PHY_END) : (PCIE_MEM_PHY_END))
3467 +#define PCIE_IO_PHY_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_IO_PHY_BASE) : (PCIE_IO_PHY_BASE))
3468 +#define PCIE_IO_PHY_PORT_TO_END(X) ((X) > 0 ? (PCIE1_IO_PHY_END) : (PCIE_IO_PHY_END))
3469 +#define PCIE_APP_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_APP_LOGIC_REG) : (PCIE_APP_LOGIC_REG))
3470 +#define PCIE_RC_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_RC_CFG_BASE) : (PCIE_RC_CFG_BASE))
3471 +#define PCIE_PHY_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_PDI_BASE) : (PCIE_PDI_BASE))
3473 +/* PCIe Application Logic Register */
3474 +/* RC Core Control Register */
3475 +#define PCIE_RC_CCR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x10)
3476 +/* This should be enabled after initializing configuratin registers
3477 + * Also should check link status retraining bit
3479 +#define PCIE_RC_CCR_LTSSM_ENABLE 0x00000001 /* Enable LTSSM to continue link establishment */
3481 +/* RC Core Debug Register */
3482 +#define PCIE_RC_DR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x14)
3483 +#define PCIE_RC_DR_DLL_UP 0x00000001 /* Data Link Layer Up */
3484 +#define PCIE_RC_DR_CURRENT_POWER_STATE 0x0000000E /* Current Power State */
3485 +#define PCIE_RC_DR_CURRENT_POWER_STATE_S 1
3486 +#define PCIE_RC_DR_CURRENT_LTSSM_STATE 0x000001F0 /* Current LTSSM State */
3487 +#define PCIE_RC_DR_CURRENT_LTSSM_STATE_S 4
3489 +#define PCIE_RC_DR_PM_DEV_STATE 0x00000E00 /* Power Management D-State */
3490 +#define PCIE_RC_DR_PM_DEV_STATE_S 9
3492 +#define PCIE_RC_DR_PM_ENABLED 0x00001000 /* Power Management State from PMU */
3493 +#define PCIE_RC_DR_PME_EVENT_ENABLED 0x00002000 /* Power Management Event Enable State */
3494 +#define PCIE_RC_DR_AUX_POWER_ENABLED 0x00004000 /* Auxiliary Power Enable */
3496 +/* Current Power State Definition */
3498 + PCIE_RC_DR_D0 = 0,
3499 + PCIE_RC_DR_D1, /* Not supported */
3500 + PCIE_RC_DR_D2, /* Not supported */
3505 +/* PHY Link Status Register */
3506 +#define PCIE_PHY_SR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x18)
3507 +#define PCIE_PHY_SR_PHY_LINK_UP 0x00000001 /* PHY Link Up/Down Indicator */
3509 +/* Electromechanical Control Register */
3510 +#define PCIE_EM_CR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x1C)
3511 +#define PCIE_EM_CR_CARD_IS_PRESENT 0x00000001 /* Card Presence Detect State */
3512 +#define PCIE_EM_CR_MRL_OPEN 0x00000002 /* MRL Sensor State */
3513 +#define PCIE_EM_CR_POWER_FAULT_SET 0x00000004 /* Power Fault Detected */
3514 +#define PCIE_EM_CR_MRL_SENSOR_SET 0x00000008 /* MRL Sensor Changed */
3515 +#define PCIE_EM_CR_PRESENT_DETECT_SET 0x00000010 /* Card Presense Detect Changed */
3516 +#define PCIE_EM_CR_CMD_CPL_INT_SET 0x00000020 /* Command Complete Interrupt */
3517 +#define PCIE_EM_CR_SYS_INTERLOCK_SET 0x00000040 /* System Electromechanical IterLock Engaged */
3518 +#define PCIE_EM_CR_ATTENTION_BUTTON_SET 0x00000080 /* Attention Button Pressed */
3520 +/* Interrupt Status Register */
3521 +#define PCIE_IR_SR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x20)
3522 +#define PCIE_IR_SR_PME_CAUSE_MSI 0x00000002 /* MSI caused by PME */
3523 +#define PCIE_IR_SR_HP_PME_WAKE_GEN 0x00000004 /* Hotplug PME Wake Generation */
3524 +#define PCIE_IR_SR_HP_MSI 0x00000008 /* Hotplug MSI */
3525 +#define PCIE_IR_SR_AHB_LU_ERR 0x00000030 /* AHB Bridge Lookup Error Signals */
3526 +#define PCIE_IR_SR_AHB_LU_ERR_S 4
3527 +#define PCIE_IR_SR_INT_MSG_NUM 0x00003E00 /* Interrupt Message Number */
3528 +#define PCIE_IR_SR_INT_MSG_NUM_S 9
3529 +#define PCIE_IR_SR_AER_INT_MSG_NUM 0xF8000000 /* Advanced Error Interrupt Message Number */
3530 +#define PCIE_IR_SR_AER_INT_MSG_NUM_S 27
3532 +/* Message Control Register */
3533 +#define PCIE_MSG_CR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x30)
3534 +#define PCIE_MSG_CR_GEN_PME_TURN_OFF_MSG 0x00000001 /* Generate PME Turn Off Message */
3535 +#define PCIE_MSG_CR_GEN_UNLOCK_MSG 0x00000002 /* Generate Unlock Message */
3537 +#define PCIE_VDM_DR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x34)
3539 +/* Vendor-Defined Message Requester ID Register */
3540 +#define PCIE_VDM_RID(X) (PCIE_APP_PORT_TO_BASE (X) + 0x38)
3541 +#define PCIE_VDM_RID_VENROR_MSG_REQ_ID 0x0000FFFF
3542 +#define PCIE_VDM_RID_VDMRID_S 0
3544 +/* ASPM Control Register */
3545 +#define PCIE_ASPM_CR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x40)
3546 +#define PCIE_ASPM_CR_HOT_RST 0x00000001 /* Hot Reset Request to the downstream device */
3547 +#define PCIE_ASPM_CR_REQ_EXIT_L1 0x00000002 /* Request to Exit L1 */
3548 +#define PCIE_ASPM_CR_REQ_ENTER_L1 0x00000004 /* Request to Enter L1 */
3550 +/* Vendor Message DW0 Register */
3551 +#define PCIE_VM_MSG_DW0(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x50)
3552 +#define PCIE_VM_MSG_DW0_TYPE 0x0000001F /* Message type */
3553 +#define PCIE_VM_MSG_DW0_TYPE_S 0
3554 +#define PCIE_VM_MSG_DW0_FORMAT 0x00000060 /* Format */
3555 +#define PCIE_VM_MSG_DW0_FORMAT_S 5
3556 +#define PCIE_VM_MSG_DW0_TC 0x00007000 /* Traffic Class */
3557 +#define PCIE_VM_MSG_DW0_TC_S 12
3558 +#define PCIE_VM_MSG_DW0_ATTR 0x000C0000 /* Atrributes */
3559 +#define PCIE_VM_MSG_DW0_ATTR_S 18
3560 +#define PCIE_VM_MSG_DW0_EP_TLP 0x00100000 /* Poisoned TLP */
3561 +#define PCIE_VM_MSG_DW0_TD 0x00200000 /* TLP Digest */
3562 +#define PCIE_VM_MSG_DW0_LEN 0xFFC00000 /* Length */
3563 +#define PCIE_VM_MSG_DW0_LEN_S 22
3565 +/* Format Definition */
3567 + PCIE_VM_MSG_FORMAT_00 = 0, /* 3DW Hdr, no data*/
3568 + PCIE_VM_MSG_FORMAT_01, /* 4DW Hdr, no data */
3569 + PCIE_VM_MSG_FORMAT_10, /* 3DW Hdr, with data */
3570 + PCIE_VM_MSG_FORMAT_11, /* 4DW Hdr, with data */
3573 +/* Traffic Class Definition */
3575 + PCIE_VM_MSG_TC0 = 0,
3585 +/* Attributes Definition */
3587 + PCIE_VM_MSG_ATTR_00 = 0, /* RO and No Snoop cleared */
3588 + PCIE_VM_MSG_ATTR_01, /* RO cleared , No Snoop set */
3589 + PCIE_VM_MSG_ATTR_10, /* RO set, No Snoop cleared*/
3590 + PCIE_VM_MSG_ATTR_11, /* RO and No Snoop set */
3593 +/* Payload Size Definition */
3594 +#define PCIE_VM_MSG_LEN_MIN 0
3595 +#define PCIE_VM_MSG_LEN_MAX 1024
3597 +/* Vendor Message DW1 Register */
3598 +#define PCIE_VM_MSG_DW1(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x54)
3599 +#define PCIE_VM_MSG_DW1_FUNC_NUM 0x00000070 /* Function Number */
3600 +#define PCIE_VM_MSG_DW1_FUNC_NUM_S 8
3601 +#define PCIE_VM_MSG_DW1_CODE 0x00FF0000 /* Message Code */
3602 +#define PCIE_VM_MSG_DW1_CODE_S 16
3603 +#define PCIE_VM_MSG_DW1_TAG 0xFF000000 /* Tag */
3604 +#define PCIE_VM_MSG_DW1_TAG_S 24
3606 +#define PCIE_VM_MSG_DW2(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x58)
3607 +#define PCIE_VM_MSG_DW3(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x5C)
3609 +/* Vendor Message Request Register */
3610 +#define PCIE_VM_MSG_REQR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x60)
3611 +#define PCIE_VM_MSG_REQR_REQ 0x00000001 /* Vendor Message Request */
3614 +/* AHB Slave Side Band Control Register */
3615 +#define PCIE_AHB_SSB(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x70)
3616 +#define PCIE_AHB_SSB_REQ_BCM 0x00000001 /* Slave Reques BCM filed */
3617 +#define PCIE_AHB_SSB_REQ_EP 0x00000002 /* Slave Reques EP filed */
3618 +#define PCIE_AHB_SSB_REQ_TD 0x00000004 /* Slave Reques TD filed */
3619 +#define PCIE_AHB_SSB_REQ_ATTR 0x00000018 /* Slave Reques Attribute number */
3620 +#define PCIE_AHB_SSB_REQ_ATTR_S 3
3621 +#define PCIE_AHB_SSB_REQ_TC 0x000000E0 /* Slave Request TC Field */
3622 +#define PCIE_AHB_SSB_REQ_TC_S 5
3624 +/* AHB Master SideBand Ctrl Register */
3625 +#define PCIE_AHB_MSB(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x74)
3626 +#define PCIE_AHB_MSB_RESP_ATTR 0x00000003 /* Master Response Attribute number */
3627 +#define PCIE_AHB_MSB_RESP_ATTR_S 0
3628 +#define PCIE_AHB_MSB_RESP_BAD_EOT 0x00000004 /* Master Response Badeot filed */
3629 +#define PCIE_AHB_MSB_RESP_BCM 0x00000008 /* Master Response BCM filed */
3630 +#define PCIE_AHB_MSB_RESP_EP 0x00000010 /* Master Response EP filed */
3631 +#define PCIE_AHB_MSB_RESP_TD 0x00000020 /* Master Response TD filed */
3632 +#define PCIE_AHB_MSB_RESP_FUN_NUM 0x000003C0 /* Master Response Function number */
3633 +#define PCIE_AHB_MSB_RESP_FUN_NUM_S 6
3635 +/* AHB Control Register, fixed bus enumeration exception */
3636 +#define PCIE_AHB_CTRL(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x78)
3637 +#define PCIE_AHB_CTRL_BUS_ERROR_SUPPRESS 0x00000001
3639 +/* Interrupt Enalbe Register */
3640 +#define PCIE_IRNEN(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0xF4)
3641 +#define PCIE_IRNCR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0xF8)
3642 +#define PCIE_IRNICR(X) (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0xFC)
3644 +/* PCIe interrupt enable/control/capture register definition */
3645 +#define PCIE_IRN_AER_REPORT 0x00000001 /* AER Interrupt */
3646 +#define PCIE_IRN_AER_MSIX 0x00000002 /* Advanced Error MSI-X Interrupt */
3647 +#define PCIE_IRN_PME 0x00000004 /* PME Interrupt */
3648 +#define PCIE_IRN_HOTPLUG 0x00000008 /* Hotplug Interrupt */
3649 +#define PCIE_IRN_RX_VDM_MSG 0x00000010 /* Vendor-Defined Message Interrupt */
3650 +#define PCIE_IRN_RX_CORRECTABLE_ERR_MSG 0x00000020 /* Correctable Error Message Interrupt */
3651 +#define PCIE_IRN_RX_NON_FATAL_ERR_MSG 0x00000040 /* Non-fatal Error Message */
3652 +#define PCIE_IRN_RX_FATAL_ERR_MSG 0x00000080 /* Fatal Error Message */
3653 +#define PCIE_IRN_RX_PME_MSG 0x00000100 /* PME Message Interrupt */
3654 +#define PCIE_IRN_RX_PME_TURNOFF_ACK 0x00000200 /* PME Turnoff Ack Message Interrupt */
3655 +#define PCIE_IRN_AHB_BR_FATAL_ERR 0x00000400 /* AHB Fatal Error Interrupt */
3656 +#define PCIE_IRN_LINK_AUTO_BW_STATUS 0x00000800 /* Link Auto Bandwidth Status Interrupt */
3657 +#define PCIE_IRN_BW_MGT 0x00001000 /* Bandwidth Managment Interrupt */
3658 +#define PCIE_IRN_INTA 0x00002000 /* INTA */
3659 +#define PCIE_IRN_INTB 0x00004000 /* INTB */
3660 +#define PCIE_IRN_INTC 0x00008000 /* INTC */
3661 +#define PCIE_IRN_INTD 0x00010000 /* INTD */
3662 +#define PCIE_IRN_WAKEUP 0x00020000 /* Wake up Interrupt */
3664 +#define PCIE_RC_CORE_COMBINED_INT (PCIE_IRN_AER_REPORT | PCIE_IRN_AER_MSIX | PCIE_IRN_PME | \
3665 + PCIE_IRN_HOTPLUG | PCIE_IRN_RX_VDM_MSG | PCIE_IRN_RX_CORRECTABLE_ERR_MSG |\
3666 + PCIE_IRN_RX_NON_FATAL_ERR_MSG | PCIE_IRN_RX_FATAL_ERR_MSG | \
3667 + PCIE_IRN_RX_PME_MSG | PCIE_IRN_RX_PME_TURNOFF_ACK | PCIE_IRN_AHB_BR_FATAL_ERR | \
3668 + PCIE_IRN_LINK_AUTO_BW_STATUS | PCIE_IRN_BW_MGT)
3669 +/* PCIe RC Configuration Register */
3670 +#define PCIE_VDID(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x00)
3672 +/* Bit definition from pci_reg.h */
3673 +#define PCIE_PCICMDSTS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x04)
3674 +#define PCIE_CCRID(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x08)
3675 +#define PCIE_CLSLTHTBR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x0C) /* EP only */
3676 +/* BAR0, BAR1,Only necessary if the bridges implements a device-specific register set or memory buffer */
3677 +#define PCIE_BAR0(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x10) /* Not used*/
3678 +#define PCIE_BAR1(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x14) /* Not used */
3680 +#define PCIE_BNR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x18) /* Mandatory */
3681 +/* Bus Number Register bits */
3682 +#define PCIE_BNR_PRIMARY_BUS_NUM 0x000000FF
3683 +#define PCIE_BNR_PRIMARY_BUS_NUM_S 0
3684 +#define PCIE_PNR_SECONDARY_BUS_NUM 0x0000FF00
3685 +#define PCIE_PNR_SECONDARY_BUS_NUM_S 8
3686 +#define PCIE_PNR_SUB_BUS_NUM 0x00FF0000
3687 +#define PCIE_PNR_SUB_BUS_NUM_S 16
3689 +/* IO Base/Limit Register bits */
3690 +#define PCIE_IOBLSECS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x1C) /* RC only */
3691 +#define PCIE_IOBLSECS_32BIT_IO_ADDR 0x00000001
3692 +#define PCIE_IOBLSECS_IO_BASE_ADDR 0x000000F0
3693 +#define PCIE_IOBLSECS_IO_BASE_ADDR_S 4
3694 +#define PCIE_IOBLSECS_32BIT_IOLIMT 0x00000100
3695 +#define PCIE_IOBLSECS_IO_LIMIT_ADDR 0x0000F000
3696 +#define PCIE_IOBLSECS_IO_LIMIT_ADDR_S 12
3698 +/* Non-prefetchable Memory Base/Limit Register bit */
3699 +#define PCIE_MBML(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x20) /* RC only */
3700 +#define PCIE_MBML_MEM_BASE_ADDR 0x0000FFF0
3701 +#define PCIE_MBML_MEM_BASE_ADDR_S 4
3702 +#define PCIE_MBML_MEM_LIMIT_ADDR 0xFFF00000
3703 +#define PCIE_MBML_MEM_LIMIT_ADDR_S 20
3705 +/* Prefetchable Memory Base/Limit Register bit */
3706 +#define PCIE_PMBL(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x24) /* RC only */
3707 +#define PCIE_PMBL_64BIT_ADDR 0x00000001
3708 +#define PCIE_PMBL_UPPER_12BIT 0x0000FFF0
3709 +#define PCIE_PMBL_UPPER_12BIT_S 4
3710 +#define PCIE_PMBL_E64MA 0x00010000
3711 +#define PCIE_PMBL_END_ADDR 0xFFF00000
3712 +#define PCIE_PMBL_END_ADDR_S 20
3713 +#define PCIE_PMBU32(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x28) /* RC only */
3714 +#define PCIE_PMLU32(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x2C) /* RC only */
3716 +/* I/O Base/Limit Upper 16 bits register */
3717 +#define PCIE_IO_BANDL(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x30) /* RC only */
3718 +#define PCIE_IO_BANDL_UPPER_16BIT_IO_BASE 0x0000FFFF
3719 +#define PCIE_IO_BANDL_UPPER_16BIT_IO_BASE_S 0
3720 +#define PCIE_IO_BANDL_UPPER_16BIT_IO_LIMIT 0xFFFF0000
3721 +#define PCIE_IO_BANDL_UPPER_16BIT_IO_LIMIT_S 16
3723 +#define PCIE_CPR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x34)
3724 +#define PCIE_EBBAR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x38)
3726 +/* Interrupt and Secondary Bridge Control Register */
3727 +#define PCIE_INTRBCTRL(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x3C)
3729 +#define PCIE_INTRBCTRL_INT_LINE 0x000000FF
3730 +#define PCIE_INTRBCTRL_INT_LINE_S 0
3731 +#define PCIE_INTRBCTRL_INT_PIN 0x0000FF00
3732 +#define PCIE_INTRBCTRL_INT_PIN_S 8
3733 +#define PCIE_INTRBCTRL_PARITY_ERR_RESP_ENABLE 0x00010000 /* #PERR */
3734 +#define PCIE_INTRBCTRL_SERR_ENABLE 0x00020000 /* #SERR */
3735 +#define PCIE_INTRBCTRL_ISA_ENABLE 0x00040000 /* ISA enable, IO 64KB only */
3736 +#define PCIE_INTRBCTRL_VGA_ENABLE 0x00080000 /* VGA enable */
3737 +#define PCIE_INTRBCTRL_VGA_16BIT_DECODE 0x00100000 /* VGA 16bit decode */
3738 +#define PCIE_INTRBCTRL_RST_SECONDARY_BUS 0x00400000 /* Secondary bus rest, hot rest, 1ms */
3739 +/* Others are read only */
3741 + PCIE_INTRBCTRL_INT_NON = 0,
3742 + PCIE_INTRBCTRL_INTA,
3743 + PCIE_INTRBCTRL_INTB,
3744 + PCIE_INTRBCTRL_INTC,
3745 + PCIE_INTRBCTRL_INTD,
3748 +#define PCIE_PM_CAPR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x40)
3750 +/* Power Management Control and Status Register */
3751 +#define PCIE_PM_CSR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x44)
3753 +#define PCIE_PM_CSR_POWER_STATE 0x00000003 /* Power State */
3754 +#define PCIE_PM_CSR_POWER_STATE_S 0
3755 +#define PCIE_PM_CSR_SW_RST 0x00000008 /* Soft Reset Enabled */
3756 +#define PCIE_PM_CSR_PME_ENABLE 0x00000100 /* PME Enable */
3757 +#define PCIE_PM_CSR_PME_STATUS 0x00008000 /* PME status */
3759 +/* MSI Capability Register for EP */
3760 +#define PCIE_MCAPR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x50)
3762 +#define PCIE_MCAPR_MSI_CAP_ID 0x000000FF /* MSI Capability ID */
3763 +#define PCIE_MCAPR_MSI_CAP_ID_S 0
3764 +#define PCIE_MCAPR_MSI_NEXT_CAP_PTR 0x0000FF00 /* Next Capability Pointer */
3765 +#define PCIE_MCAPR_MSI_NEXT_CAP_PTR_S 8
3766 +#define PCIE_MCAPR_MSI_ENABLE 0x00010000 /* MSI Enable */
3767 +#define PCIE_MCAPR_MULTI_MSG_CAP 0x000E0000 /* Multiple Message Capable */
3768 +#define PCIE_MCAPR_MULTI_MSG_CAP_S 17
3769 +#define PCIE_MCAPR_MULTI_MSG_ENABLE 0x00700000 /* Multiple Message Enable */
3770 +#define PCIE_MCAPR_MULTI_MSG_ENABLE_S 20
3771 +#define PCIE_MCAPR_ADDR64_CAP 0X00800000 /* 64-bit Address Capable */
3773 +/* MSI Message Address Register */
3774 +#define PCIE_MA(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x54)
3776 +#define PCIE_MA_ADDR_MASK 0xFFFFFFFC /* Message Address */
3778 +/* MSI Message Upper Address Register */
3779 +#define PCIE_MUA(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x58)
3781 +/* MSI Message Data Register */
3782 +#define PCIE_MD(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x5C)
3784 +#define PCIE_MD_DATA 0x0000FFFF /* Message Data */
3785 +#define PCIE_MD_DATA_S 0
3787 +/* PCI Express Capability Register */
3788 +#define PCIE_XCAP(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x70)
3790 +#define PCIE_XCAP_ID 0x000000FF /* PCI Express Capability ID */
3791 +#define PCIE_XCAP_ID_S 0
3792 +#define PCIE_XCAP_NEXT_CAP 0x0000FF00 /* Next Capability Pointer */
3793 +#define PCIE_XCAP_NEXT_CAP_S 8
3794 +#define PCIE_XCAP_VER 0x000F0000 /* PCI Express Capability Version */
3795 +#define PCIE_XCAP_VER_S 16
3796 +#define PCIE_XCAP_DEV_PORT_TYPE 0x00F00000 /* Device Port Type */
3797 +#define PCIE_XCAP_DEV_PORT_TYPE_S 20
3798 +#define PCIE_XCAP_SLOT_IMPLEMENTED 0x01000000 /* Slot Implemented */
3799 +#define PCIE_XCAP_MSG_INT_NUM 0x3E000000 /* Interrupt Message Number */
3800 +#define PCIE_XCAP_MSG_INT_NUM_S 25
3802 +/* Device Capability Register */
3803 +#define PCIE_DCAP(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x74)
3805 +#define PCIE_DCAP_MAX_PAYLOAD_SIZE 0x00000007 /* Max Payload size */
3806 +#define PCIE_DCAP_MAX_PAYLOAD_SIZE_S 0
3807 +#define PCIE_DCAP_PHANTOM_FUNC 0x00000018 /* Phanton Function, not supported */
3808 +#define PCIE_DCAP_PHANTOM_FUNC_S 3
3809 +#define PCIE_DCAP_EXT_TAG 0x00000020 /* Extended Tag Field */
3810 +#define PCIE_DCAP_EP_L0S_LATENCY 0x000001C0 /* EP L0s latency only */
3811 +#define PCIE_DCAP_EP_L0S_LATENCY_S 6
3812 +#define PCIE_DCAP_EP_L1_LATENCY 0x00000E00 /* EP L1 latency only */
3813 +#define PCIE_DCAP_EP_L1_LATENCY_S 9
3814 +#define PCIE_DCAP_ROLE_BASE_ERR_REPORT 0x00008000 /* Role Based ERR */
3816 +/* Maximum payload size supported */
3818 + PCIE_MAX_PAYLOAD_128 = 0,
3819 + PCIE_MAX_PAYLOAD_256,
3820 + PCIE_MAX_PAYLOAD_512,
3821 + PCIE_MAX_PAYLOAD_1024,
3822 + PCIE_MAX_PAYLOAD_2048,
3823 + PCIE_MAX_PAYLOAD_4096,
3826 +/* Device Control and Status Register */
3827 +#define PCIE_DCTLSTS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x78)
3829 +#define PCIE_DCTLSTS_CORRECTABLE_ERR_EN 0x00000001 /* COR-ERR */
3830 +#define PCIE_DCTLSTS_NONFATAL_ERR_EN 0x00000002 /* Non-fatal ERR */
3831 +#define PCIE_DCTLSTS_FATAL_ERR_EN 0x00000004 /* Fatal ERR */
3832 +#define PCIE_DCTLSYS_UR_REQ_EN 0x00000008 /* UR ERR */
3833 +#define PCIE_DCTLSTS_RELAXED_ORDERING_EN 0x00000010 /* Enable relaxing ordering */
3834 +#define PCIE_DCTLSTS_MAX_PAYLOAD_SIZE 0x000000E0 /* Max payload mask */
3835 +#define PCIE_DCTLSTS_MAX_PAYLOAD_SIZE_S 5
3836 +#define PCIE_DCTLSTS_EXT_TAG_EN 0x00000100 /* Extended tag field */
3837 +#define PCIE_DCTLSTS_PHANTOM_FUNC_EN 0x00000200 /* Phantom Function Enable */
3838 +#define PCIE_DCTLSTS_AUX_PM_EN 0x00000400 /* AUX Power PM Enable */
3839 +#define PCIE_DCTLSTS_NO_SNOOP_EN 0x00000800 /* Enable no snoop, except root port*/
3840 +#define PCIE_DCTLSTS_MAX_READ_SIZE 0x00007000 /* Max Read Request size*/
3841 +#define PCIE_DCTLSTS_MAX_READ_SIZE_S 12
3842 +#define PCIE_DCTLSTS_CORRECTABLE_ERR 0x00010000 /* COR-ERR Detected */
3843 +#define PCIE_DCTLSTS_NONFATAL_ERR 0x00020000 /* Non-Fatal ERR Detected */
3844 +#define PCIE_DCTLSTS_FATAL_ER 0x00040000 /* Fatal ERR Detected */
3845 +#define PCIE_DCTLSTS_UNSUPPORTED_REQ 0x00080000 /* UR Detected */
3846 +#define PCIE_DCTLSTS_AUX_POWER 0x00100000 /* Aux Power Detected */
3847 +#define PCIE_DCTLSTS_TRANSACT_PENDING 0x00200000 /* Transaction pending */
3849 +#define PCIE_DCTLSTS_ERR_EN (PCIE_DCTLSTS_CORRECTABLE_ERR_EN | \
3850 + PCIE_DCTLSTS_NONFATAL_ERR_EN | PCIE_DCTLSTS_FATAL_ERR_EN | \
3851 + PCIE_DCTLSYS_UR_REQ_EN)
3853 +/* Link Capability Register */
3854 +#define PCIE_LCAP(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x7C)
3855 +#define PCIE_LCAP_MAX_LINK_SPEED 0x0000000F /* Max link speed, 0x1 by default */
3856 +#define PCIE_LCAP_MAX_LINK_SPEED_S 0
3857 +#define PCIE_LCAP_MAX_LENGTH_WIDTH 0x000003F0 /* Maxium Length Width */
3858 +#define PCIE_LCAP_MAX_LENGTH_WIDTH_S 4
3859 +#define PCIE_LCAP_ASPM_LEVEL 0x00000C00 /* Active State Link PM Support */
3860 +#define PCIE_LCAP_ASPM_LEVEL_S 10
3861 +#define PCIE_LCAP_L0S_EIXT_LATENCY 0x00007000 /* L0s Exit Latency */
3862 +#define PCIE_LCAP_L0S_EIXT_LATENCY_S 12
3863 +#define PCIE_LCAP_L1_EXIT_LATENCY 0x00038000 /* L1 Exit Latency */
3864 +#define PCIE_LCAP_L1_EXIT_LATENCY_S 15
3865 +#define PCIE_LCAP_CLK_PM 0x00040000 /* Clock Power Management */
3866 +#define PCIE_LCAP_SDER 0x00080000 /* Surprise Down Error Reporting */
3867 +#define PCIE_LCAP_DLL_ACTIVE_REPROT 0x00100000 /* Data Link Layer Active Reporting Capable */
3868 +#define PCIE_LCAP_PORT_NUM 0xFF0000000 /* Port number */
3869 +#define PCIE_LCAP_PORT_NUM_S 24
3871 +/* Maximum Length width definition */
3872 +#define PCIE_MAX_LENGTH_WIDTH_RES 0x00
3873 +#define PCIE_MAX_LENGTH_WIDTH_X1 0x01 /* Default */
3874 +#define PCIE_MAX_LENGTH_WIDTH_X2 0x02
3875 +#define PCIE_MAX_LENGTH_WIDTH_X4 0x04
3876 +#define PCIE_MAX_LENGTH_WIDTH_X8 0x08
3877 +#define PCIE_MAX_LENGTH_WIDTH_X12 0x0C
3878 +#define PCIE_MAX_LENGTH_WIDTH_X16 0x10
3879 +#define PCIE_MAX_LENGTH_WIDTH_X32 0x20
3881 +/* Active State Link PM definition */
3883 + PCIE_ASPM_RES0 = 0,
3884 + PCIE_ASPM_L0S_ENTRY_SUPPORT, /* L0s */
3886 + PCIE_ASPM_L0S_L1_ENTRY_SUPPORT, /* L0s and L1, default */
3889 +/* L0s Exit Latency definition */
3891 + PCIE_L0S_EIXT_LATENCY_L64NS = 0, /* < 64 ns */
3892 + PCIE_L0S_EIXT_LATENCY_B64A128, /* > 64 ns < 128 ns */
3893 + PCIE_L0S_EIXT_LATENCY_B128A256, /* > 128 ns < 256 ns */
3894 + PCIE_L0S_EIXT_LATENCY_B256A512, /* > 256 ns < 512 ns */
3895 + PCIE_L0S_EIXT_LATENCY_B512TO1U, /* > 512 ns < 1 us */
3896 + PCIE_L0S_EIXT_LATENCY_B1A2U, /* > 1 us < 2 us */
3897 + PCIE_L0S_EIXT_LATENCY_B2A4U, /* > 2 us < 4 us */
3898 + PCIE_L0S_EIXT_LATENCY_M4US, /* > 4 us */
3901 +/* L1 Exit Latency definition */
3903 + PCIE_L1_EXIT_LATENCY_L1US = 0, /* < 1 us */
3904 + PCIE_L1_EXIT_LATENCY_B1A2, /* > 1 us < 2 us */
3905 + PCIE_L1_EXIT_LATENCY_B2A4, /* > 2 us < 4 us */
3906 + PCIE_L1_EXIT_LATENCY_B4A8, /* > 4 us < 8 us */
3907 + PCIE_L1_EXIT_LATENCY_B8A16, /* > 8 us < 16 us */
3908 + PCIE_L1_EXIT_LATENCY_B16A32, /* > 16 us < 32 us */
3909 + PCIE_L1_EXIT_LATENCY_B32A64, /* > 32 us < 64 us */
3910 + PCIE_L1_EXIT_LATENCY_M64US, /* > 64 us */
3913 +/* Link Control and Status Register */
3914 +#define PCIE_LCTLSTS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x80)
3915 +#define PCIE_LCTLSTS_ASPM_ENABLE 0x00000003 /* Active State Link PM Control */
3916 +#define PCIE_LCTLSTS_ASPM_ENABLE_S 0
3917 +#define PCIE_LCTLSTS_RCB128 0x00000008 /* Read Completion Boundary 128*/
3918 +#define PCIE_LCTLSTS_LINK_DISABLE 0x00000010 /* Link Disable */
3919 +#define PCIE_LCTLSTS_RETRIAN_LINK 0x00000020 /* Retrain Link */
3920 +#define PCIE_LCTLSTS_COM_CLK_CFG 0x00000040 /* Common Clock Configuration */
3921 +#define PCIE_LCTLSTS_EXT_SYNC 0x00000080 /* Extended Synch */
3922 +#define PCIE_LCTLSTS_CLK_PM_EN 0x00000100 /* Enable Clock Powerm Management */
3923 +#define PCIE_LCTLSTS_LINK_SPEED 0x000F0000 /* Link Speed */
3924 +#define PCIE_LCTLSTS_LINK_SPEED_S 16
3925 +#define PCIE_LCTLSTS_NEGOTIATED_LINK_WIDTH 0x03F00000 /* Negotiated Link Width */
3926 +#define PCIE_LCTLSTS_NEGOTIATED_LINK_WIDTH_S 20
3927 +#define PCIE_LCTLSTS_RETRAIN_PENDING 0x08000000 /* Link training is ongoing */
3928 +#define PCIE_LCTLSTS_SLOT_CLK_CFG 0x10000000 /* Slot Clock Configuration */
3929 +#define PCIE_LCTLSTS_DLL_ACTIVE 0x20000000 /* Data Link Layer Active */
3931 +/* Slot Capabilities Register */
3932 +#define PCIE_SLCAP(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x84)
3934 +/* Slot Capabilities */
3935 +#define PCIE_SLCTLSTS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x88)
3937 +/* Root Control and Capability Register */
3938 +#define PCIE_RCTLCAP(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x8C)
3939 +#define PCIE_RCTLCAP_SERR_ON_CORRECTABLE_ERR 0x00000001 /* #SERR on COR-ERR */
3940 +#define PCIE_RCTLCAP_SERR_ON_NONFATAL_ERR 0x00000002 /* #SERR on Non-Fatal ERR */
3941 +#define PCIE_RCTLCAP_SERR_ON_FATAL_ERR 0x00000004 /* #SERR on Fatal ERR */
3942 +#define PCIE_RCTLCAP_PME_INT_EN 0x00000008 /* PME Interrupt Enable */
3943 +#define PCIE_RCTLCAP_SERR_ENABLE (PCIE_RCTLCAP_SERR_ON_CORRECTABLE_ERR | \
3944 + PCIE_RCTLCAP_SERR_ON_NONFATAL_ERR | PCIE_RCTLCAP_SERR_ON_FATAL_ERR)
3945 +/* Root Status Register */
3946 +#define PCIE_RSTS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x90)
3947 +#define PCIE_RSTS_PME_REQ_ID 0x0000FFFF /* PME Request ID */
3948 +#define PCIE_RSTS_PME_REQ_ID_S 0
3949 +#define PCIE_RSTS_PME_STATUS 0x00010000 /* PME Status */
3950 +#define PCIE_RSTS_PME_PENDING 0x00020000 /* PME Pending */
3952 +/* PCI Express Enhanced Capability Header */
3953 +#define PCIE_ENHANCED_CAP(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x100)
3954 +#define PCIE_ENHANCED_CAP_ID 0x0000FFFF /* PCI Express Extended Capability ID */
3955 +#define PCIE_ENHANCED_CAP_ID_S 0
3956 +#define PCIE_ENHANCED_CAP_VER 0x000F0000 /* Capability Version */
3957 +#define PCIE_ENHANCED_CAP_VER_S 16
3958 +#define PCIE_ENHANCED_CAP_NEXT_OFFSET 0xFFF00000 /* Next Capability Offset */
3959 +#define PCIE_ENHANCED_CAP_NEXT_OFFSET_S 20
3961 +/* Uncorrectable Error Status Register */
3962 +#define PCIE_UES_R(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x104)
3963 +#define PCIE_DATA_LINK_PROTOCOL_ERR 0x00000010 /* Data Link Protocol Error Status */
3964 +#define PCIE_SURPRISE_DOWN_ERROR 0x00000020 /* Surprise Down Error Status */
3965 +#define PCIE_POISONED_TLP 0x00001000 /* Poisoned TLP Status */
3966 +#define PCIE_FC_PROTOCOL_ERR 0x00002000 /* Flow Control Protocol Error Status */
3967 +#define PCIE_COMPLETION_TIMEOUT 0x00004000 /* Completion Timeout Status */
3968 +#define PCIE_COMPLETOR_ABORT 0x00008000 /* Completer Abort Error */
3969 +#define PCIE_UNEXPECTED_COMPLETION 0x00010000 /* Unexpected Completion Status */
3970 +#define PCIE_RECEIVER_OVERFLOW 0x00020000 /* Receive Overflow Status */
3971 +#define PCIE_MALFORNED_TLP 0x00040000 /* Malformed TLP Stauts */
3972 +#define PCIE_ECRC_ERR 0x00080000 /* ECRC Error Stauts */
3973 +#define PCIE_UR_REQ 0x00100000 /* Unsupported Request Error Status */
3974 +#define PCIE_ALL_UNCORRECTABLE_ERR (PCIE_DATA_LINK_PROTOCOL_ERR | PCIE_SURPRISE_DOWN_ERROR | \
3975 + PCIE_POISONED_TLP | PCIE_FC_PROTOCOL_ERR | PCIE_COMPLETION_TIMEOUT | \
3976 + PCIE_COMPLETOR_ABORT | PCIE_UNEXPECTED_COMPLETION | PCIE_RECEIVER_OVERFLOW |\
3977 + PCIE_MALFORNED_TLP | PCIE_ECRC_ERR | PCIE_UR_REQ)
3979 +/* Uncorrectable Error Mask Register, Mask means no report */
3980 +#define PCIE_UEMR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x108)
3982 +/* Uncorrectable Error Severity Register */
3983 +#define PCIE_UESR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x10C)
3985 +/* Correctable Error Status Register */
3986 +#define PCIE_CESR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x110)
3987 +#define PCIE_RX_ERR 0x00000001 /* Receive Error Status */
3988 +#define PCIE_BAD_TLP 0x00000040 /* Bad TLP Status */
3989 +#define PCIE_BAD_DLLP 0x00000080 /* Bad DLLP Status */
3990 +#define PCIE_REPLAY_NUM_ROLLOVER 0x00000100 /* Replay Number Rollover Status */
3991 +#define PCIE_REPLAY_TIMER_TIMEOUT_ERR 0x00001000 /* Reply Timer Timeout Status */
3992 +#define PCIE_ADVISORY_NONFTAL_ERR 0x00002000 /* Advisory Non-Fatal Error Status */
3993 +#define PCIE_CORRECTABLE_ERR (PCIE_RX_ERR | PCIE_BAD_TLP | PCIE_BAD_DLLP | PCIE_REPLAY_NUM_ROLLOVER |\
3994 + PCIE_REPLAY_TIMER_TIMEOUT_ERR | PCIE_ADVISORY_NONFTAL_ERR)
3996 +/* Correctable Error Mask Register */
3997 +#define PCIE_CEMR(X) (volatile u32*)(PCIE_RC_CFG_BASE + 0x114)
3999 +/* Advanced Error Capabilities and Control Register */
4000 +#define PCIE_AECCR(X) (volatile u32*)(PCIE_RC_CFG_BASE + 0x118)
4001 +#define PCIE_AECCR_FIRST_ERR_PTR 0x0000001F /* First Error Pointer */
4002 +#define PCIE_AECCR_FIRST_ERR_PTR_S 0
4003 +#define PCIE_AECCR_ECRC_GEN_CAP 0x00000020 /* ECRC Generation Capable */
4004 +#define PCIE_AECCR_ECRC_GEN_EN 0x00000040 /* ECRC Generation Enable */
4005 +#define PCIE_AECCR_ECRC_CHECK_CAP 0x00000080 /* ECRC Check Capable */
4006 +#define PCIE_AECCR_ECRC_CHECK_EN 0x00000100 /* ECRC Check Enable */
4008 +/* Header Log Register 1 */
4009 +#define PCIE_HLR1(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x11C)
4011 +/* Header Log Register 2 */
4012 +#define PCIE_HLR2(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x120)
4014 +/* Header Log Register 3 */
4015 +#define PCIE_HLR3(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x124)
4017 +/* Header Log Register 4 */
4018 +#define PCIE_HLR4(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x128)
4020 +/* Root Error Command Register */
4021 +#define PCIE_RECR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x12C)
4022 +#define PCIE_RECR_CORRECTABLE_ERR_REPORT_EN 0x00000001 /* COR-ERR */
4023 +#define PCIE_RECR_NONFATAL_ERR_REPORT_EN 0x00000002 /* Non-Fatal ERR */
4024 +#define PCIE_RECR_FATAL_ERR_REPORT_EN 0x00000004 /* Fatal ERR */
4025 +#define PCIE_RECR_ERR_REPORT_EN (PCIE_RECR_CORRECTABLE_ERR_REPORT_EN | \
4026 + PCIE_RECR_NONFATAL_ERR_REPORT_EN | PCIE_RECR_FATAL_ERR_REPORT_EN)
4028 +/* Root Error Status Register */
4029 +#define PCIE_RESR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x130)
4030 +#define PCIE_RESR_CORRECTABLE_ERR 0x00000001 /* COR-ERR Receveid */
4031 +#define PCIE_RESR_MULTI_CORRECTABLE_ERR 0x00000002 /* Multiple COR-ERR Received */
4032 +#define PCIE_RESR_FATAL_NOFATAL_ERR 0x00000004 /* ERR Fatal/Non-Fatal Received */
4033 +#define PCIE_RESR_MULTI_FATAL_NOFATAL_ERR 0x00000008 /* Multiple ERR Fatal/Non-Fatal Received */
4034 +#define PCIE_RESR_FIRST_UNCORRECTABLE_FATAL_ERR 0x00000010 /* First UN-COR Fatal */
4035 +#define PCIR_RESR_NON_FATAL_ERR 0x00000020 /* Non-Fatal Error Message Received */
4036 +#define PCIE_RESR_FATAL_ERR 0x00000040 /* Fatal Message Received */
4037 +#define PCIE_RESR_AER_INT_MSG_NUM 0xF8000000 /* Advanced Error Interrupt Message Number */
4038 +#define PCIE_RESR_AER_INT_MSG_NUM_S 27
4040 +/* Error Source Indentification Register */
4041 +#define PCIE_ESIR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x134)
4042 +#define PCIE_ESIR_CORRECTABLE_ERR_SRC_ID 0x0000FFFF
4043 +#define PCIE_ESIR_CORRECTABLE_ERR_SRC_ID_S 0
4044 +#define PCIE_ESIR_FATAL_NON_FATAL_SRC_ID 0xFFFF0000
4045 +#define PCIE_ESIR_FATAL_NON_FATAL_SRC_ID_S 16
4047 +/* VC Enhanced Capability Header */
4048 +#define PCIE_VC_ECH(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x140)
4050 +/* Port VC Capability Register */
4051 +#define PCIE_PVC1(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x144)
4052 +#define PCIE_PVC1_EXT_VC_CNT 0x00000007 /* Extended VC Count */
4053 +#define PCIE_PVC1_EXT_VC_CNT_S 0
4054 +#define PCIE_PVC1_LOW_PRI_EXT_VC_CNT 0x00000070 /* Low Priority Extended VC Count */
4055 +#define PCIE_PVC1_LOW_PRI_EXT_VC_CNT_S 4
4056 +#define PCIE_PVC1_REF_CLK 0x00000300 /* Reference Clock */
4057 +#define PCIE_PVC1_REF_CLK_S 8
4058 +#define PCIE_PVC1_PORT_ARB_TAB_ENTRY_SIZE 0x00000C00 /* Port Arbitration Table Entry Size */
4059 +#define PCIE_PVC1_PORT_ARB_TAB_ENTRY_SIZE_S 10
4061 +/* Extended Virtual Channel Count Defintion */
4062 +#define PCIE_EXT_VC_CNT_MIN 0
4063 +#define PCIE_EXT_VC_CNT_MAX 7
4065 +/* Port Arbitration Table Entry Size Definition */
4067 + PCIE_PORT_ARB_TAB_ENTRY_SIZE_S1BIT = 0,
4068 + PCIE_PORT_ARB_TAB_ENTRY_SIZE_S2BIT,
4069 + PCIE_PORT_ARB_TAB_ENTRY_SIZE_S4BIT,
4070 + PCIE_PORT_ARB_TAB_ENTRY_SIZE_S8BIT,
4073 +/* Port VC Capability Register 2 */
4074 +#define PCIE_PVC2(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x148)
4075 +#define PCIE_PVC2_VC_ARB_16P_FIXED_WRR 0x00000001 /* HW Fixed arbitration, 16 phase WRR */
4076 +#define PCIE_PVC2_VC_ARB_32P_WRR 0x00000002 /* 32 phase WRR */
4077 +#define PCIE_PVC2_VC_ARB_64P_WRR 0x00000004 /* 64 phase WRR */
4078 +#define PCIE_PVC2_VC_ARB_128P_WRR 0x00000008 /* 128 phase WRR */
4079 +#define PCIE_PVC2_VC_ARB_WRR 0x0000000F
4080 +#define PCIE_PVC2_VC_ARB_TAB_OFFSET 0xFF000000 /* VC arbitration table offset, not support */
4081 +#define PCIE_PVC2_VC_ARB_TAB_OFFSET_S 24
4083 +/* Port VC Control and Status Register */
4084 +#define PCIE_PVCCRSR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x14C)
4085 +#define PCIE_PVCCRSR_LOAD_VC_ARB_TAB 0x00000001 /* Load VC Arbitration Table */
4086 +#define PCIE_PVCCRSR_VC_ARB_SEL 0x0000000E /* VC Arbitration Select */
4087 +#define PCIE_PVCCRSR_VC_ARB_SEL_S 1
4088 +#define PCIE_PVCCRSR_VC_ARB_TAB_STATUS 0x00010000 /* Arbitration Status */
4090 +/* VC0 Resource Capability Register */
4091 +#define PCIE_VC0_RC(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x150)
4092 +#define PCIE_VC0_RC_PORT_ARB_HW_FIXED 0x00000001 /* HW Fixed arbitration */
4093 +#define PCIE_VC0_RC_PORT_ARB_32P_WRR 0x00000002 /* 32 phase WRR */
4094 +#define PCIE_VC0_RC_PORT_ARB_64P_WRR 0x00000004 /* 64 phase WRR */
4095 +#define PCIE_VC0_RC_PORT_ARB_128P_WRR 0x00000008 /* 128 phase WRR */
4096 +#define PCIE_VC0_RC_PORT_ARB_TM_128P_WRR 0x00000010 /* Time-based 128 phase WRR */
4097 +#define PCIE_VC0_RC_PORT_ARB_TM_256P_WRR 0x00000020 /* Time-based 256 phase WRR */
4098 +#define PCIE_VC0_RC_PORT_ARB (PCIE_VC0_RC_PORT_ARB_HW_FIXED | PCIE_VC0_RC_PORT_ARB_32P_WRR |\
4099 + PCIE_VC0_RC_PORT_ARB_64P_WRR | PCIE_VC0_RC_PORT_ARB_128P_WRR | \
4100 + PCIE_VC0_RC_PORT_ARB_TM_128P_WRR | PCIE_VC0_RC_PORT_ARB_TM_256P_WRR)
4102 +#define PCIE_VC0_RC_REJECT_SNOOP 0x00008000 /* Reject Snoop Transactioin */
4103 +#define PCIE_VC0_RC_MAX_TIMESLOTS 0x007F0000 /* Maximum time Slots */
4104 +#define PCIE_VC0_RC_MAX_TIMESLOTS_S 16
4105 +#define PCIE_VC0_RC_PORT_ARB_TAB_OFFSET 0xFF000000 /* Port Arbitration Table Offset */
4106 +#define PCIE_VC0_RC_PORT_ARB_TAB_OFFSET_S 24
4108 +/* VC0 Resource Control Register */
4109 +#define PCIE_VC0_RC0(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x154)
4110 +#define PCIE_VC0_RC0_TVM0 0x00000001 /* TC0 and VC0 */
4111 +#define PCIE_VC0_RC0_TVM1 0x00000002 /* TC1 and VC1 */
4112 +#define PCIE_VC0_RC0_TVM2 0x00000004 /* TC2 and VC2 */
4113 +#define PCIE_VC0_RC0_TVM3 0x00000008 /* TC3 and VC3 */
4114 +#define PCIE_VC0_RC0_TVM4 0x00000010 /* TC4 and VC4 */
4115 +#define PCIE_VC0_RC0_TVM5 0x00000020 /* TC5 and VC5 */
4116 +#define PCIE_VC0_RC0_TVM6 0x00000040 /* TC6 and VC6 */
4117 +#define PCIE_VC0_RC0_TVM7 0x00000080 /* TC7 and VC7 */
4118 +#define PCIE_VC0_RC0_TC_VC 0x000000FF /* TC/VC mask */
4120 +#define PCIE_VC0_RC0_LOAD_PORT_ARB_TAB 0x00010000 /* Load Port Arbitration Table */
4121 +#define PCIE_VC0_RC0_PORT_ARB_SEL 0x000E0000 /* Port Arbitration Select */
4122 +#define PCIE_VC0_RC0_PORT_ARB_SEL_S 17
4123 +#define PCIE_VC0_RC0_VC_ID 0x07000000 /* VC ID */
4124 +#define PCIE_VC0_RC0_VC_ID_S 24
4125 +#define PCIE_VC0_RC0_VC_EN 0x80000000 /* VC Enable */
4127 +/* VC0 Resource Status Register */
4128 +#define PCIE_VC0_RSR0(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x158)
4129 +#define PCIE_VC0_RSR0_PORT_ARB_TAB_STATUS 0x00010000 /* Port Arbitration Table Status,not used */
4130 +#define PCIE_VC0_RSR0_VC_NEG_PENDING 0x00020000 /* VC Negotiation Pending */
4132 +/* Ack Latency Timer and Replay Timer Register */
4133 +#define PCIE_ALTRT(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x700)
4134 +#define PCIE_ALTRT_ROUND_TRIP_LATENCY_LIMIT 0x0000FFFF /* Round Trip Latency Time Limit */
4135 +#define PCIE_ALTRT_ROUND_TRIP_LATENCY_LIMIT_S 0
4136 +#define PCIE_ALTRT_REPLAY_TIME_LIMIT 0xFFFF0000 /* Replay Time Limit */
4137 +#define PCIE_ALTRT_REPLAY_TIME_LIMIT_S 16
4139 +/* Other Message Register */
4140 +#define PCIE_OMR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x704)
4142 +/* Port Force Link Register */
4143 +#define PCIE_PFLR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x708)
4144 +#define PCIE_PFLR_LINK_NUM 0x000000FF /* Link Number */
4145 +#define PCIE_PFLR_LINK_NUM_S 0
4146 +#define PCIE_PFLR_FORCE_LINK 0x00008000 /* Force link */
4147 +#define PCIE_PFLR_LINK_STATE 0x003F0000 /* Link State */
4148 +#define PCIE_PFLR_LINK_STATE_S 16
4149 +#define PCIE_PFLR_LOW_POWER_ENTRY_CNT 0xFF000000 /* Low Power Entrance Count, only for EP */
4150 +#define PCIE_PFLR_LOW_POWER_ENTRY_CNT_S 24
4152 +/* Ack Frequency Register */
4153 +#define PCIE_AFR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x70C)
4154 +#define PCIE_AFR_AF 0x000000FF /* Ack Frequency */
4155 +#define PCIE_AFR_AF_S 0
4156 +#define PCIE_AFR_FTS_NUM 0x0000FF00 /* The number of Fast Training Sequence from L0S to L0 */
4157 +#define PCIE_AFR_FTS_NUM_S 8
4158 +#define PCIE_AFR_COM_FTS_NUM 0x00FF0000 /* N_FTS; when common clock is used*/
4159 +#define PCIE_AFR_COM_FTS_NUM_S 16
4160 +#define PCIE_AFR_L0S_ENTRY_LATENCY 0x07000000 /* L0s Entrance Latency */
4161 +#define PCIE_AFR_L0S_ENTRY_LATENCY_S 24
4162 +#define PCIE_AFR_L1_ENTRY_LATENCY 0x38000000 /* L1 Entrance Latency */
4163 +#define PCIE_AFR_L1_ENTRY_LATENCY_S 27
4164 +#define PCIE_AFR_FTS_NUM_DEFAULT 32
4165 +#define PCIE_AFR_L0S_ENTRY_LATENCY_DEFAULT 7
4166 +#define PCIE_AFR_L1_ENTRY_LATENCY_DEFAULT 5
4168 +/* Port Link Control Register */
4169 +#define PCIE_PLCR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x710)
4170 +#define PCIE_PLCR_OTHER_MSG_REQ 0x00000001 /* Other Message Request */
4171 +#define PCIE_PLCR_SCRAMBLE_DISABLE 0x00000002 /* Scramble Disable */
4172 +#define PCIE_PLCR_LOOPBACK_EN 0x00000004 /* Loopback Enable */
4173 +#define PCIE_PLCR_LTSSM_HOT_RST 0x00000008 /* Force LTSSM to the hot reset */
4174 +#define PCIE_PLCR_DLL_LINK_EN 0x00000020 /* Enable Link initialization */
4175 +#define PCIE_PLCR_FAST_LINK_SIM_EN 0x00000080 /* Sets all internal timers to fast mode for simulation purposes */
4176 +#define PCIE_PLCR_LINK_MODE 0x003F0000 /* Link Mode Enable Mask */
4177 +#define PCIE_PLCR_LINK_MODE_S 16
4178 +#define PCIE_PLCR_CORRUPTED_CRC_EN 0x02000000 /* Enabled Corrupt CRC */
4180 +/* Lane Skew Register */
4181 +#define PCIE_LSR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x714)
4182 +#define PCIE_LSR_LANE_SKEW_NUM 0x00FFFFFF /* Insert Lane Skew for Transmit, not applicable */
4183 +#define PCIE_LSR_LANE_SKEW_NUM_S 0
4184 +#define PCIE_LSR_FC_DISABLE 0x01000000 /* Disable of Flow Control */
4185 +#define PCIE_LSR_ACKNAK_DISABLE 0x02000000 /* Disable of Ack/Nak */
4186 +#define PCIE_LSR_LANE_DESKEW_DISABLE 0x80000000 /* Disable of Lane-to-Lane Skew */
4188 +/* Symbol Number Register */
4189 +#define PCIE_SNR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x718)
4190 +#define PCIE_SNR_TS 0x0000000F /* Number of TS Symbol */
4191 +#define PCIE_SNR_TS_S 0
4192 +#define PCIE_SNR_SKP 0x00000700 /* Number of SKP Symbol */
4193 +#define PCIE_SNR_SKP_S 8
4194 +#define PCIE_SNR_REPLAY_TIMER 0x0007C000 /* Timer Modifier for Replay Timer */
4195 +#define PCIE_SNR_REPLAY_TIMER_S 14
4196 +#define PCIE_SNR_ACKNAK_LATENCY_TIMER 0x00F80000 /* Timer Modifier for Ack/Nak Latency Timer */
4197 +#define PCIE_SNR_ACKNAK_LATENCY_TIMER_S 19
4198 +#define PCIE_SNR_FC_TIMER 0x1F000000 /* Timer Modifier for Flow Control Watchdog Timer */
4199 +#define PCIE_SNR_FC_TIMER_S 28
4201 +/* Symbol Timer Register and Filter Mask Register 1 */
4202 +#define PCIE_STRFMR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x71C)
4203 +#define PCIE_STRFMR_SKP_INTERVAL 0x000007FF /* SKP lnterval Value */
4204 +#define PCIE_STRFMR_SKP_INTERVAL_S 0
4205 +#define PCIE_STRFMR_FC_WDT_DISABLE 0x00008000 /* Disable of FC Watchdog Timer */
4206 +#define PCIE_STRFMR_TLP_FUNC_MISMATCH_OK 0x00010000 /* Mask Function Mismatch Filtering for Incoming Requests */
4207 +#define PCIE_STRFMR_POISONED_TLP_OK 0x00020000 /* Mask Poisoned TLP Filtering */
4208 +#define PCIE_STRFMR_BAR_MATCH_OK 0x00040000 /* Mask BAR Match Filtering */
4209 +#define PCIE_STRFMR_TYPE1_CFG_REQ_OK 0x00080000 /* Mask Type 1 Configuration Request Filtering */
4210 +#define PCIE_STRFMR_LOCKED_REQ_OK 0x00100000 /* Mask Locked Request Filtering */
4211 +#define PCIE_STRFMR_CPL_TAG_ERR_RULES_OK 0x00200000 /* Mask Tag Error Rules for Received Completions */
4212 +#define PCIE_STRFMR_CPL_REQUESTOR_ID_MISMATCH_OK 0x00400000 /* Mask Requester ID Mismatch Error for Received Completions */
4213 +#define PCIE_STRFMR_CPL_FUNC_MISMATCH_OK 0x00800000 /* Mask Function Mismatch Error for Received Completions */
4214 +#define PCIE_STRFMR_CPL_TC_MISMATCH_OK 0x01000000 /* Mask Traffic Class Mismatch Error for Received Completions */
4215 +#define PCIE_STRFMR_CPL_ATTR_MISMATCH_OK 0x02000000 /* Mask Attribute Mismatch Error for Received Completions */
4216 +#define PCIE_STRFMR_CPL_LENGTH_MISMATCH_OK 0x04000000 /* Mask Length Mismatch Error for Received Completions */
4217 +#define PCIE_STRFMR_TLP_ECRC_ERR_OK 0x08000000 /* Mask ECRC Error Filtering */
4218 +#define PCIE_STRFMR_CPL_TLP_ECRC_OK 0x10000000 /* Mask ECRC Error Filtering for Completions */
4219 +#define PCIE_STRFMR_RX_TLP_MSG_NO_DROP 0x20000000 /* Send Message TLPs */
4220 +#define PCIE_STRFMR_RX_IO_TRANS_ENABLE 0x40000000 /* Mask Filtering of received I/O Requests */
4221 +#define PCIE_STRFMR_RX_CFG_TRANS_ENABLE 0x80000000 /* Mask Filtering of Received Configuration Requests */
4223 +#define PCIE_DEF_SKP_INTERVAL 700 /* 1180 ~1538 , 125MHz * 2, 250MHz * 1 */
4225 +/* Filter Masker Register 2 */
4226 +#define PCIE_FMR2(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x720)
4227 +#define PCIE_FMR2_VENDOR_MSG0_PASSED_TO_TRGT1 0x00000001 /* Mask RADM Filtering and Error Handling Rules */
4228 +#define PCIE_FMR2_VENDOR_MSG1_PASSED_TO_TRGT1 0x00000002 /* Mask RADM Filtering and Error Handling Rules */
4230 +/* Debug Register 0 */
4231 +#define PCIE_DBR0(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x728)
4233 +/* Debug Register 1 */
4234 +#define PCIE_DBR1(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x72C)
4236 +/* Transmit Posted FC Credit Status Register */
4237 +#define PCIE_TPFCS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x730)
4238 +#define PCIE_TPFCS_TX_P_DATA_FC_CREDITS 0x00000FFF /* Transmit Posted Data FC Credits */
4239 +#define PCIE_TPFCS_TX_P_DATA_FC_CREDITS_S 0
4240 +#define PCIE_TPFCS_TX_P_HDR_FC_CREDITS 0x000FF000 /* Transmit Posted Header FC Credits */
4241 +#define PCIE_TPFCS_TX_P_HDR_FC_CREDITS_S 12
4243 +/* Transmit Non-Posted FC Credit Status */
4244 +#define PCIE_TNPFCS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x734)
4245 +#define PCIE_TNPFCS_TX_NP_DATA_FC_CREDITS 0x00000FFF /* Transmit Non-Posted Data FC Credits */
4246 +#define PCIE_TNPFCS_TX_NP_DATA_FC_CREDITS_S 0
4247 +#define PCIE_TNPFCS_TX_NP_HDR_FC_CREDITS 0x000FF000 /* Transmit Non-Posted Header FC Credits */
4248 +#define PCIE_TNPFCS_TX_NP_HDR_FC_CREDITS_S 12
4250 +/* Transmit Complete FC Credit Status Register */
4251 +#define PCIE_TCFCS(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x738)
4252 +#define PCIE_TCFCS_TX_CPL_DATA_FC_CREDITS 0x00000FFF /* Transmit Completion Data FC Credits */
4253 +#define PCIE_TCFCS_TX_CPL_DATA_FC_CREDITS_S 0
4254 +#define PCIE_TCFCS_TX_CPL_HDR_FC_CREDITS 0x000FF000 /* Transmit Completion Header FC Credits */
4255 +#define PCIE_TCFCS_TX_CPL_HDR_FC_CREDITS_S 12
4257 +/* Queue Status Register */
4258 +#define PCIE_QSR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x73C)
4259 +#define PCIE_QSR_WAIT_UPDATE_FC_DLL 0x00000001 /* Received TLP FC Credits Not Returned */
4260 +#define PCIE_QSR_TX_RETRY_BUF_NOT_EMPTY 0x00000002 /* Transmit Retry Buffer Not Empty */
4261 +#define PCIE_QSR_RX_QUEUE_NOT_EMPTY 0x00000004 /* Received Queue Not Empty */
4263 +/* VC Transmit Arbitration Register 1 */
4264 +#define PCIE_VCTAR1(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x740)
4265 +#define PCIE_VCTAR1_WRR_WEIGHT_VC0 0x000000FF /* WRR Weight for VC0 */
4266 +#define PCIE_VCTAR1_WRR_WEIGHT_VC1 0x0000FF00 /* WRR Weight for VC1 */
4267 +#define PCIE_VCTAR1_WRR_WEIGHT_VC2 0x00FF0000 /* WRR Weight for VC2 */
4268 +#define PCIE_VCTAR1_WRR_WEIGHT_VC3 0xFF000000 /* WRR Weight for VC3 */
4270 +/* VC Transmit Arbitration Register 2 */
4271 +#define PCIE_VCTAR2(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x744)
4272 +#define PCIE_VCTAR2_WRR_WEIGHT_VC4 0x000000FF /* WRR Weight for VC4 */
4273 +#define PCIE_VCTAR2_WRR_WEIGHT_VC5 0x0000FF00 /* WRR Weight for VC5 */
4274 +#define PCIE_VCTAR2_WRR_WEIGHT_VC6 0x00FF0000 /* WRR Weight for VC6 */
4275 +#define PCIE_VCTAR2_WRR_WEIGHT_VC7 0xFF000000 /* WRR Weight for VC7 */
4277 +/* VC0 Posted Receive Queue Control Register */
4278 +#define PCIE_VC0_PRQCR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x748)
4279 +#define PCIE_VC0_PRQCR_P_DATA_CREDITS 0x00000FFF /* VC0 Posted Data Credits */
4280 +#define PCIE_VC0_PRQCR_P_DATA_CREDITS_S 0
4281 +#define PCIE_VC0_PRQCR_P_HDR_CREDITS 0x000FF000 /* VC0 Posted Header Credits */
4282 +#define PCIE_VC0_PRQCR_P_HDR_CREDITS_S 12
4283 +#define PCIE_VC0_PRQCR_P_TLP_QUEUE_MODE 0x00E00000 /* VC0 Posted TLP Queue Mode */
4284 +#define PCIE_VC0_PRQCR_P_TLP_QUEUE_MODE_S 20
4285 +#define PCIE_VC0_PRQCR_TLP_RELAX_ORDER 0x40000000 /* TLP Type Ordering for VC0 */
4286 +#define PCIE_VC0_PRQCR_VC_STRICT_ORDER 0x80000000 /* VC0 Ordering for Receive Queues */
4288 +/* VC0 Non-Posted Receive Queue Control */
4289 +#define PCIE_VC0_NPRQCR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x74C)
4290 +#define PCIE_VC0_NPRQCR_NP_DATA_CREDITS 0x00000FFF /* VC0 Non-Posted Data Credits */
4291 +#define PCIE_VC0_NPRQCR_NP_DATA_CREDITS_S 0
4292 +#define PCIE_VC0_NPRQCR_NP_HDR_CREDITS 0x000FF000 /* VC0 Non-Posted Header Credits */
4293 +#define PCIE_VC0_NPRQCR_NP_HDR_CREDITS_S 12
4294 +#define PCIE_VC0_NPRQCR_NP_TLP_QUEUE_MODE 0x00E00000 /* VC0 Non-Posted TLP Queue Mode */
4295 +#define PCIE_VC0_NPRQCR_NP_TLP_QUEUE_MODE_S 20
4297 +/* VC0 Completion Receive Queue Control */
4298 +#define PCIE_VC0_CRQCR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x750)
4299 +#define PCIE_VC0_CRQCR_CPL_DATA_CREDITS 0x00000FFF /* VC0 Completion TLP Queue Mode */
4300 +#define PCIE_VC0_CRQCR_CPL_DATA_CREDITS_S 0
4301 +#define PCIE_VC0_CRQCR_CPL_HDR_CREDITS 0x000FF000 /* VC0 Completion Header Credits */
4302 +#define PCIE_VC0_CRQCR_CPL_HDR_CREDITS_S 12
4303 +#define PCIE_VC0_CRQCR_CPL_TLP_QUEUE_MODE 0x00E00000 /* VC0 Completion Data Credits */
4304 +#define PCIE_VC0_CRQCR_CPL_TLP_QUEUE_MODE_S 21
4306 +/* Applicable to the above three registers */
4308 + PCIE_VC0_TLP_QUEUE_MODE_STORE_FORWARD = 1,
4309 + PCIE_VC0_TLP_QUEUE_MODE_CUT_THROUGH = 2,
4310 + PCIE_VC0_TLP_QUEUE_MODE_BYPASS = 4,
4313 +/* VC0 Posted Buffer Depth Register */
4314 +#define PCIE_VC0_PBD(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x7A8)
4315 +#define PCIE_VC0_PBD_P_DATA_QUEUE_ENTRIES 0x00003FFF /* VC0 Posted Data Queue Depth */
4316 +#define PCIE_VC0_PBD_P_DATA_QUEUE_ENTRIES_S 0
4317 +#define PCIE_VC0_PBD_P_HDR_QUEUE_ENTRIES 0x03FF0000 /* VC0 Posted Header Queue Depth */
4318 +#define PCIE_VC0_PBD_P_HDR_QUEUE_ENTRIES_S 16
4320 +/* VC0 Non-Posted Buffer Depth Register */
4321 +#define PCIE_VC0_NPBD(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x7AC)
4322 +#define PCIE_VC0_NPBD_NP_DATA_QUEUE_ENTRIES 0x00003FFF /* VC0 Non-Posted Data Queue Depth */
4323 +#define PCIE_VC0_NPBD_NP_DATA_QUEUE_ENTRIES_S 0
4324 +#define PCIE_VC0_NPBD_NP_HDR_QUEUE_ENTRIES 0x03FF0000 /* VC0 Non-Posted Header Queue Depth */
4325 +#define PCIE_VC0_NPBD_NP_HDR_QUEUE_ENTRIES_S 16
4327 +/* VC0 Completion Buffer Depth Register */
4328 +#define PCIE_VC0_CBD(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x7B0)
4329 +#define PCIE_VC0_CBD_CPL_DATA_QUEUE_ENTRIES 0x00003FFF /* C0 Completion Data Queue Depth */
4330 +#define PCIE_VC0_CBD_CPL_DATA_QUEUE_ENTRIES_S 0
4331 +#define PCIE_VC0_CBD_CPL_HDR_QUEUE_ENTRIES 0x03FF0000 /* VC0 Completion Header Queue Depth */
4332 +#define PCIE_VC0_CBD_CPL_HDR_QUEUE_ENTRIES_S 16
4334 +/* PHY Status Register, all zeros in VR9 */
4335 +#define PCIE_PHYSR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x810)
4337 +/* PHY Control Register, all zeros in VR9 */
4338 +#define PCIE_PHYCR(X) (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x814)
4341 + * PCIe PDI PHY register definition, suppose all the following
4342 + * stuff is confidential.
4343 + * XXX, detailed bit definition
4345 +#define PCIE_PHY_PLL_CTRL1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x22 << 1))
4346 +#define PCIE_PHY_PLL_CTRL2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x23 << 1))
4347 +#define PCIE_PHY_PLL_CTRL3(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x24 << 1))
4348 +#define PCIE_PHY_PLL_CTRL4(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x25 << 1))
4349 +#define PCIE_PHY_PLL_CTRL5(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x26 << 1))
4350 +#define PCIE_PHY_PLL_CTRL6(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x27 << 1))
4351 +#define PCIE_PHY_PLL_CTRL7(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x28 << 1))
4352 +#define PCIE_PHY_PLL_A_CTRL1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x29 << 1))
4353 +#define PCIE_PHY_PLL_A_CTRL2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x2A << 1))
4354 +#define PCIE_PHY_PLL_A_CTRL3(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x2B << 1))
4355 +#define PCIE_PHY_PLL_STATUS(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x2C << 1))
4357 +#define PCIE_PHY_TX1_CTRL1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x30 << 1))
4358 +#define PCIE_PHY_TX1_CTRL2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x31 << 1))
4359 +#define PCIE_PHY_TX1_CTRL3(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x32 << 1))
4360 +#define PCIE_PHY_TX1_A_CTRL1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x33 << 1))
4361 +#define PCIE_PHY_TX1_A_CTRL2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x34 << 1))
4362 +#define PCIE_PHY_TX1_MOD1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x35 << 1))
4363 +#define PCIE_PHY_TX1_MOD2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x36 << 1))
4364 +#define PCIE_PHY_TX1_MOD3(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x37 << 1))
4366 +#define PCIE_PHY_TX2_CTRL1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x38 << 1))
4367 +#define PCIE_PHY_TX2_CTRL2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x39 << 1))
4368 +#define PCIE_PHY_TX2_A_CTRL1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x3B << 1))
4369 +#define PCIE_PHY_TX2_A_CTRL2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x3C << 1))
4370 +#define PCIE_PHY_TX2_MOD1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x3D << 1))
4371 +#define PCIE_PHY_TX2_MOD2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x3E << 1))
4372 +#define PCIE_PHY_TX2_MOD3(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x3F << 1))
4374 +#define PCIE_PHY_RX1_CTRL1(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x50 << 1))
4375 +#define PCIE_PHY_RX1_CTRL2(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x51 << 1))
4376 +#define PCIE_PHY_RX1_CDR(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x52 << 1))
4377 +#define PCIE_PHY_RX1_EI(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x53 << 1))
4378 +#define PCIE_PHY_RX1_A_CTRL(X) (PCIE_PHY_PORT_TO_BASE(X) + (0x55 << 1))
4380 +/* Interrupt related stuff */
4381 +#define PCIE_LEGACY_DISABLE 0
4382 +#define PCIE_LEGACY_INTA 1
4383 +#define PCIE_LEGACY_INTB 2
4384 +#define PCIE_LEGACY_INTC 3
4385 +#define PCIE_LEGACY_INTD 4
4386 +#define PCIE_LEGACY_INT_MAX PCIE_LEGACY_INTD
4388 +#endif /* IFXMIPS_PCIE_REG_H */
4391 +++ b/arch/mips/pci/ifxmips_pcie_vr9.h
4393 +/****************************************************************************
4394 + Copyright (c) 2010
4395 + Lantiq Deutschland GmbH
4396 + Am Campeon 3; 85579 Neubiberg, Germany
4398 + For licensing information, see the file 'LICENSE' in the root folder of
4399 + this software module.
4401 + *****************************************************************************/
4403 + \file ifxmips_pcie_vr9.h
4405 + \brief PCIe RC driver vr9 specific file
4408 +#ifndef IFXMIPS_PCIE_VR9_H
4409 +#define IFXMIPS_PCIE_VR9_H
4411 +#include <linux/types.h>
4412 +#include <linux/delay.h>
4414 +#include <linux/gpio.h>
4415 +#include <lantiq_soc.h>
4417 +#define IFX_PCIE_GPIO_RESET 238
4419 +#define IFX_REG_R32 ltq_r32
4420 +#define IFX_REG_W32 ltq_w32
4421 +#define CONFIG_IFX_PCIE_HW_SWAP
4422 +#define IFX_RCU_AHB_ENDIAN ((volatile u32*)(IFX_RCU + 0x004C))
4423 +#define IFX_RCU_RST_REQ ((volatile u32*)(IFX_RCU + 0x0010))
4424 +#define IFX_RCU_AHB_BE_PCIE_PDI 0x00000080 /* Configure PCIE PDI module in big endian*/
4426 +#define IFX_RCU (KSEG1 | 0x1F203000)
4427 +#define IFX_RCU_AHB_BE_PCIE_M 0x00000001 /* Configure AHB master port that connects to PCIe RC in big endian */
4428 +#define IFX_RCU_AHB_BE_PCIE_S 0x00000010 /* Configure AHB slave port that connects to PCIe RC in little endian */
4429 +#define IFX_RCU_AHB_BE_XBAR_M 0x00000002 /* Configure AHB master port that connects to XBAR in big endian */
4430 +#define CONFIG_IFX_PCIE_PHY_36MHZ_MODE
4432 +#define IFX_PMU1_MODULE_PCIE_PHY (0)
4433 +#define IFX_PMU1_MODULE_PCIE_CTRL (1)
4434 +#define IFX_PMU1_MODULE_PDI (4)
4435 +#define IFX_PMU1_MODULE_MSI (5)
4437 +#define IFX_PMU_MODULE_PCIE_L0_CLK (31)
4440 +#define IFX_GPIO (KSEG1 | 0x1E100B00)
4441 +#define ALT0 ((volatile u32*)(IFX_GPIO + 0x007c))
4442 +#define ALT1 ((volatile u32*)(IFX_GPIO + 0x0080))
4443 +#define OD ((volatile u32*)(IFX_GPIO + 0x0084))
4444 +#define DIR ((volatile u32*)(IFX_GPIO + 0x0078))
4445 +#define OUT ((volatile u32*)(IFX_GPIO + 0x0070))
4448 +static inline void pcie_ep_gpio_rst_init(int pcie_port)
4451 + gpio_request(IFX_PCIE_GPIO_RESET, "pcie-reset");
4452 + gpio_direction_output(IFX_PCIE_GPIO_RESET, 1);
4453 + gpio_set_value(IFX_PCIE_GPIO_RESET, 1);
4455 +/* ifx_gpio_pin_reserve(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
4456 + ifx_gpio_output_set(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
4457 + ifx_gpio_dir_out_set(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
4458 + ifx_gpio_altsel0_clear(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
4459 + ifx_gpio_altsel1_clear(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
4460 + ifx_gpio_open_drain_set(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);*/
4463 +static inline void pcie_ahb_pmu_setup(void)
4465 + /* Enable AHB bus master/slave */
4467 + clk = clk_get_sys("1d900000.pcie", "ahb");
4470 + //AHBM_PMU_SETUP(IFX_PMU_ENABLE);
4471 + //AHBS_PMU_SETUP(IFX_PMU_ENABLE);
4474 +static inline void pcie_rcu_endian_setup(int pcie_port)
4478 + reg = IFX_REG_R32(IFX_RCU_AHB_ENDIAN);
4479 +#ifdef CONFIG_IFX_PCIE_HW_SWAP
4480 + reg |= IFX_RCU_AHB_BE_PCIE_M;
4481 + reg |= IFX_RCU_AHB_BE_PCIE_S;
4482 + reg &= ~IFX_RCU_AHB_BE_XBAR_M;
4484 + reg |= IFX_RCU_AHB_BE_PCIE_M;
4485 + reg &= ~IFX_RCU_AHB_BE_PCIE_S;
4486 + reg &= ~IFX_RCU_AHB_BE_XBAR_M;
4487 +#endif /* CONFIG_IFX_PCIE_HW_SWAP */
4488 + IFX_REG_W32(reg, IFX_RCU_AHB_ENDIAN);
4489 + IFX_PCIE_PRINT(PCIE_MSG_REG, "%s IFX_RCU_AHB_ENDIAN: 0x%08x\n", __func__, IFX_REG_R32(IFX_RCU_AHB_ENDIAN));
4492 +static inline void pcie_phy_pmu_enable(int pcie_port)
4495 + clk = clk_get_sys("1d900000.pcie", "phy");
4498 + //PCIE_PHY_PMU_SETUP(IFX_PMU_ENABLE);
4501 +static inline void pcie_phy_pmu_disable(int pcie_port)
4504 + clk = clk_get_sys("1d900000.pcie", "phy");
4507 +// PCIE_PHY_PMU_SETUP(IFX_PMU_DISABLE);
4510 +static inline void pcie_pdi_big_endian(int pcie_port)
4514 + /* SRAM2PDI endianness control. */
4515 + reg = IFX_REG_R32(IFX_RCU_AHB_ENDIAN);
4516 + /* Config AHB->PCIe and PDI endianness */
4517 + reg |= IFX_RCU_AHB_BE_PCIE_PDI;
4518 + IFX_REG_W32(reg, IFX_RCU_AHB_ENDIAN);
4521 +static inline void pcie_pdi_pmu_enable(int pcie_port)
4523 + /* Enable PDI to access PCIe PHY register */
4525 + clk = clk_get_sys("1d900000.pcie", "pdi");
4527 + //PDI_PMU_SETUP(IFX_PMU_ENABLE);
4530 +static inline void pcie_core_rst_assert(int pcie_port)
4534 + reg = IFX_REG_R32(IFX_RCU_RST_REQ);
4536 + /* Reset PCIe PHY & Core, bit 22, bit 26 may be affected if write it directly */
4537 + reg |= 0x00400000;
4538 + IFX_REG_W32(reg, IFX_RCU_RST_REQ);
4541 +static inline void pcie_core_rst_deassert(int pcie_port)
4545 + /* Make sure one micro-second delay */
4548 + /* Reset PCIe PHY & Core, bit 22 */
4549 + reg = IFX_REG_R32(IFX_RCU_RST_REQ);
4550 + reg &= ~0x00400000;
4551 + IFX_REG_W32(reg, IFX_RCU_RST_REQ);
4554 +static inline void pcie_phy_rst_assert(int pcie_port)
4558 + reg = IFX_REG_R32(IFX_RCU_RST_REQ);
4559 + reg |= 0x00001000; /* Bit 12 */
4560 + IFX_REG_W32(reg, IFX_RCU_RST_REQ);
4563 +static inline void pcie_phy_rst_deassert(int pcie_port)
4567 + /* Make sure one micro-second delay */
4570 + reg = IFX_REG_R32(IFX_RCU_RST_REQ);
4571 + reg &= ~0x00001000; /* Bit 12 */
4572 + IFX_REG_W32(reg, IFX_RCU_RST_REQ);
4575 +static inline void pcie_device_rst_assert(int pcie_port)
4577 + printk("%s:%s[%d]\n", __FILE__, __func__, __LINE__);
4578 + gpio_set_value(IFX_PCIE_GPIO_RESET, 0);
4579 +// ifx_gpio_output_clear(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
4582 +static inline void pcie_device_rst_deassert(int pcie_port)
4585 + printk("%s:%s[%d]\n", __FILE__, __func__, __LINE__);
4586 + gpio_direction_output(IFX_PCIE_GPIO_RESET, 1);
4587 +// gpio_set_value(IFX_PCIE_GPIO_RESET, 1);
4588 + //ifx_gpio_output_set(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
4591 +static inline void pcie_core_pmu_setup(int pcie_port)
4594 + clk = clk_get_sys("1d900000.pcie", "ctl");
4596 + clk = clk_get_sys("1d900000.pcie", "bus");
4599 + /* PCIe Core controller enabled */
4600 +// PCIE_CTRL_PMU_SETUP(IFX_PMU_ENABLE);
4602 + /* Enable PCIe L0 Clock */
4603 +// PCIE_L0_CLK_PMU_SETUP(IFX_PMU_ENABLE);
4606 +static inline void pcie_msi_init(int pcie_port)
4609 + pcie_msi_pic_init(pcie_port);
4610 + clk = clk_get_sys("ltq_pcie", "msi");
4612 +// MSI_PMU_SETUP(IFX_PMU_ENABLE);
4616 +ifx_pcie_bus_nr_deduct(u32 bus_number, int pcie_port)
4618 + u32 tbus_number = bus_number;
4620 +#ifdef CONFIG_IFX_PCI
4621 + if (pcibios_host_nr() > 1) {
4622 + tbus_number -= pcibios_1st_host_bus_nr();
4624 +#endif /* CONFIG_IFX_PCI */
4625 + return tbus_number;
4629 +ifx_pcie_bus_enum_hack(struct pci_bus *bus, u32 devfn, int where, u32 value, int pcie_port, int read)
4631 + struct pci_dev *pdev;
4632 + u32 tvalue = value;
4634 + /* Sanity check */
4635 + pdev = pci_get_slot(bus, devfn);
4636 + if (pdev == NULL) {
4640 + /* Only care about PCI bridge */
4641 + if (pdev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
4645 + if (read) { /* Read hack */
4646 + #ifdef CONFIG_IFX_PCI
4647 + if (pcibios_host_nr() > 1) {
4648 + tvalue = ifx_pcie_bus_enum_read_hack(where, tvalue);
4650 + #endif /* CONFIG_IFX_PCI */
4652 + else { /* Write hack */
4653 + #ifdef CONFIG_IFX_PCI
4654 + if (pcibios_host_nr() > 1) {
4655 + tvalue = ifx_pcie_bus_enum_write_hack(where, tvalue);
4662 +#endif /* IFXMIPS_PCIE_VR9_H */
4664 --- a/arch/mips/pci/pci.c
4665 +++ b/arch/mips/pci/pci.c
4666 @@ -250,6 +250,31 @@ static int __init pcibios_init(void)
4668 subsys_initcall(pcibios_init);
4670 +int pcibios_host_nr(void)
4673 + struct pci_controller *hose;
4674 + for (count = 0, hose = hose_head; hose; hose = hose->next, count++) {
4679 +EXPORT_SYMBOL(pcibios_host_nr);
4681 +int pcibios_1st_host_bus_nr(void)
4684 + struct pci_controller *hose = hose_head;
4686 + if (hose != NULL) {
4687 + if (hose->bus != NULL) {
4688 + bus_nr = hose->bus->number + 1;
4693 +EXPORT_SYMBOL(pcibios_1st_host_bus_nr);
4695 static int pcibios_enable_resources(struct pci_dev *dev, int mask)
4698 --- a/drivers/pci/pcie/aer/Kconfig
4699 +++ b/drivers/pci/pcie/aer/Kconfig
4702 boolean "Root Port Advanced Error Reporting support"
4703 depends on PCIEPORTBUS
4707 This enables PCI Express Root Port Advanced Error Reporting
4708 (AER) driver support. Error reporting messages sent to Root
4709 --- a/include/linux/pci.h
4710 +++ b/include/linux/pci.h
4711 @@ -1038,6 +1038,8 @@ void pci_walk_bus(struct pci_bus *top, i
4712 int pci_cfg_space_size_ext(struct pci_dev *dev);
4713 int pci_cfg_space_size(struct pci_dev *dev);
4714 unsigned char pci_bus_max_busnr(struct pci_bus *bus);
4715 +int pcibios_host_nr(void);
4716 +int pcibios_1st_host_bus_nr(void);
4717 void pci_setup_bridge(struct pci_bus *bus);
4718 resource_size_t pcibios_window_alignment(struct pci_bus *bus,
4719 unsigned long type);
4720 --- a/include/linux/pci_ids.h
4721 +++ b/include/linux/pci_ids.h
4722 @@ -1040,6 +1040,12 @@
4723 #define PCI_DEVICE_ID_SGI_LITHIUM 0x1002
4724 #define PCI_DEVICE_ID_SGI_IOC4 0x100a
4726 +#define PCI_VENDOR_ID_INFINEON 0x15D1
4727 +#define PCI_DEVICE_ID_INFINEON_DANUBE 0x000F
4728 +#define PCI_DEVICE_ID_INFINEON_PCIE 0x0011
4729 +#define PCI_VENDOR_ID_LANTIQ 0x1BEF
4730 +#define PCI_DEVICE_ID_LANTIQ_PCIE 0x00
4732 #define PCI_VENDOR_ID_WINBOND 0x10ad
4733 #define PCI_DEVICE_ID_WINBOND_82C105 0x0105
4734 #define PCI_DEVICE_ID_WINBOND_83C553 0x0565
projects / openwrt.git / blob