target/linux/lantiq/patches-3.2/0055-MIPS-lantiq-pcie-add-pcie-driver.patch

   1 From a53d622001ae396d89c9abacb62f3c3c7fbd3c13 Mon Sep 17 00:00:00 2001
   2 From: John Crispin <blogic@openwrt.org>
   3 Date: Thu, 8 Mar 2012 15:57:33 +0100
   4 Subject: [PATCH 55/70]  MIPS: lantiq: pcie: add pcie driver
   5
   6 ---
   7  arch/mips/Kconfig                 |    1 +
   8  arch/mips/lantiq/Kconfig          |    4 -
   9  arch/mips/lantiq/xway/Kconfig     |   21 +
  10  arch/mips/pci/Makefile            |    2 +
  11  arch/mips/pci/fixup-lantiq-pcie.c |   81 +++
  12  arch/mips/pci/pci.c               |   25 +
  13  arch/mips/pci/pcie-lantiq-msi.c   |  399 +++++++++++
  14  arch/mips/pci/pcie-lantiq-phy.c   |  408 ++++++++++++
  15  arch/mips/pci/pcie-lantiq.c       | 1146 ++++++++++++++++++++++++++++++++
  16  arch/mips/pci/pcie-lantiq.h       | 1305 +++++++++++++++++++++++++++++++++++++
  17  10 files changed, 3388 insertions(+), 4 deletions(-)
  18  create mode 100644 arch/mips/pci/fixup-lantiq-pcie.c
  19  create mode 100644 arch/mips/pci/pcie-lantiq-msi.c
  20  create mode 100644 arch/mips/pci/pcie-lantiq-phy.c
  21  create mode 100644 arch/mips/pci/pcie-lantiq.c
  22  create mode 100644 arch/mips/pci/pcie-lantiq.h
  23
  24 diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig
  25 index 1b78cd7..bbaff9b 100644
  26 --- a/arch/mips/Kconfig
  27 +++ b/arch/mips/Kconfig
  28 @@ -2329,6 +2329,7 @@ config PCI_DOMAINS
  29         bool
  30
  31  source "drivers/pci/Kconfig"
  32 +source "drivers/pci/pcie/Kconfig"
  33
  34  #
  35  # ISA support is now enabled via select.  Too many systems still have the one
  36 diff --git a/arch/mips/lantiq/Kconfig b/arch/mips/lantiq/Kconfig
  37 index dde9fc6..d21d9d4 100644
  38 --- a/arch/mips/lantiq/Kconfig
  39 +++ b/arch/mips/lantiq/Kconfig
  40 @@ -22,10 +22,6 @@ config SOC_FALCON
  41
  42  endchoice
  43
  44 -config PCI_LANTIQ
  45 -       bool "PCI Support"
  46 -       depends on SOC_XWAY && PCI
  47 -
  48  source "arch/mips/lantiq/xway/Kconfig"
  49  source "arch/mips/lantiq/falcon/Kconfig"
  50
  51 diff --git a/arch/mips/lantiq/xway/Kconfig b/arch/mips/lantiq/xway/Kconfig
  52 index 2b857de..54a51ff 100644
  53 --- a/arch/mips/lantiq/xway/Kconfig
  54 +++ b/arch/mips/lantiq/xway/Kconfig
  55 @@ -8,6 +8,27 @@ config LANTIQ_MACH_EASY50712
  56
  57  endmenu
  58
  59 +choice
  60 +       prompt "PCI"
  61 +       default PCI_LANTIQ_NONE
  62 +
  63 +config PCI_LANTIQ_NONE
  64 +       bool "None"
  65 +
  66 +config PCI_LANTIQ
  67 +       bool "PCI Support"
  68 +       depends on PCI
  69 +
  70 +config PCIE_LANTIQ
  71 +       bool "PCIE Support"
  72 +       select ARCH_SUPPORTS_MSI
  73 +
  74 +endchoice
  75 +
  76 +config PCIE_LANTIQ_MSI
  77 +       bool
  78 +       depends on PCIE_LANTIQ && PCI_MSI
  79 +       default y
  80  endif
  81
  82  if SOC_AMAZON_SE
  83 diff --git a/arch/mips/pci/Makefile b/arch/mips/pci/Makefile
  84 index 3ca5f75..3386888 100644
  85 --- a/arch/mips/pci/Makefile
  86 +++ b/arch/mips/pci/Makefile
  87 @@ -42,6 +42,8 @@ obj-$(CONFIG_SIBYTE_BCM1x80)  += pci-bcm1480.o pci-bcm1480ht.o
  88  obj-$(CONFIG_SNI_RM)           += fixup-sni.o ops-sni.o
  89  obj-$(CONFIG_LANTIQ)           += fixup-lantiq.o
  90  obj-$(CONFIG_PCI_LANTIQ)       += pci-lantiq.o ops-lantiq.o
  91 +obj-$(CONFIG_PCIE_LANTIQ)      += pcie-lantiq-phy.o pcie-lantiq.o fixup-lantiq-pcie.o
  92 +obj-$(CONFIG_PCIE_LANTIQ_MSI)  += pcie-lantiq-msi.o
  93  obj-$(CONFIG_TANBAC_TB0219)    += fixup-tb0219.o
  94  obj-$(CONFIG_TANBAC_TB0226)    += fixup-tb0226.o
  95  obj-$(CONFIG_TANBAC_TB0287)    += fixup-tb0287.o
  96 diff --git a/arch/mips/pci/fixup-lantiq-pcie.c b/arch/mips/pci/fixup-lantiq-pcie.c
  97 new file mode 100644
  98 index 0000000..84517df
  99 --- /dev/null
 100 +++ b/arch/mips/pci/fixup-lantiq-pcie.c
 101 @@ -0,0 +1,81 @@
 102 +/******************************************************************************
 103 +**
 104 +** FILE NAME    : ifxmips_fixup_pcie.c
 105 +** PROJECT      : IFX UEIP for VRX200
 106 +** MODULES      : PCIe
 107 +**
 108 +** DATE         : 02 Mar 2009
 109 +** AUTHOR       : Lei Chuanhua
 110 +** DESCRIPTION  : PCIe Root Complex Driver
 111 +** COPYRIGHT    :       Copyright (c) 2009
 112 +**                      Infineon Technologies AG
 113 +**                      Am Campeon 1-12, 85579 Neubiberg, Germany
 114 +**
 115 +**    This program is free software; you can redistribute it and/or modify
 116 +**    it under the terms of the GNU General Public License as published by
 117 +**    the Free Software Foundation; either version 2 of the License, or
 118 +**    (at your option) any later version.
 119 +** HISTORY
 120 +** $Version $Date        $Author         $Comment
 121 +** 0.0.1    17 Mar,2009  Lei Chuanhua    Initial version
 122 +*******************************************************************************/
 123 +/*!
 124 + \file ifxmips_fixup_pcie.c
 125 + \ingroup IFX_PCIE
 126 + \brief PCIe Fixup functions source file
 127 +*/
 128 +#include <linux/pci.h>
 129 +#include <linux/pci_regs.h>
 130 +#include <linux/pci_ids.h>
 131 +
 132 +#include <lantiq_soc.h>
 133 +
 134 +#include "pcie-lantiq.h"
 135 +
 136 +#define PCI_VENDOR_ID_INFINEON         0x15D1
 137 +#define PCI_DEVICE_ID_INFINEON_DANUBE  0x000F
 138 +#define PCI_DEVICE_ID_INFINEON_PCIE    0x0011
 139 +#define PCI_VENDOR_ID_LANTIQ        0x1BEF
 140 +#define PCI_DEVICE_ID_LANTIQ_PCIE       0x0011
 141 +
 142 +
 143 +
 144 +static void __devinit
 145 +ifx_pcie_fixup_resource(struct pci_dev *dev)
 146 +{
 147 +    u32 reg;
 148 +
 149 +    IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s dev %s: enter\n", __func__, pci_name(dev));
 150 +
 151 +    IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s: fixup host controller %s (%04x:%04x)\n",
 152 +        __func__, pci_name(dev), dev->vendor, dev->device);
 153 +
 154 +   /* Setup COMMAND register */
 155 +    reg = PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER /* |
 156 +          PCI_COMMAND_INTX_DISABLE */| PCI_COMMAND_SERR;
 157 +    pci_write_config_word(dev, PCI_COMMAND, reg);
 158 +    IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s dev %s: exit\n", __func__, pci_name(dev));
 159 +}
 160 +DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INFINEON, PCI_DEVICE_ID_INFINEON_PCIE, ifx_pcie_fixup_resource);
 161 +DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_LANTIQ, PCI_VENDOR_ID_LANTIQ, ifx_pcie_fixup_resource);
 162 +
 163 +static void __devinit
 164 +ifx_pcie_rc_class_early_fixup(struct pci_dev *dev)
 165 +{
 166 +    IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s dev %s: enter\n", __func__, pci_name(dev));
 167 +
 168 +    if (dev->devfn == PCI_DEVFN(0, 0) &&
 169 +        (dev->class >> 8) == PCI_CLASS_BRIDGE_HOST) {
 170 +
 171 +        dev->class = (PCI_CLASS_BRIDGE_PCI << 8) | (dev->class & 0xff);
 172 +
 173 +        printk(KERN_INFO "%s: fixed pcie host bridge to pci-pci bridge\n", __func__);
 174 +    }
 175 +    IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s dev %s: exit\n", __func__, pci_name(dev));
 176 +}
 177 +
 178 +DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INFINEON, PCI_DEVICE_ID_INFINEON_PCIE,
 179 +     ifx_pcie_rc_class_early_fixup);
 180 +
 181 +DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_LANTIQ, PCI_DEVICE_ID_LANTIQ_PCIE,
 182 +     ifx_pcie_rc_class_early_fixup);
 183 diff --git a/arch/mips/pci/pci.c b/arch/mips/pci/pci.c
 184 index 41af7fa..2239cda 100644
 185 --- a/arch/mips/pci/pci.c
 186 +++ b/arch/mips/pci/pci.c
 187 @@ -167,6 +167,31 @@ static int __init pcibios_init(void)
 188
 189  subsys_initcall(pcibios_init);
 190
 191 +int pcibios_host_nr(void)
 192 +{
 193 +    int count;
 194 +    struct pci_controller *hose;
 195 +    for (count = 0, hose = hose_head; hose; hose = hose->next, count++) {
 196 +        ;
 197 +    }
 198 +    return count;
 199 +}
 200 +EXPORT_SYMBOL(pcibios_host_nr);
 201 +
 202 +int pcibios_1st_host_bus_nr(void)
 203 +{
 204 +    int bus_nr = 0;
 205 +    struct pci_controller *hose = hose_head;
 206 +
 207 +    if (hose != NULL) {
 208 +        if (hose->bus != NULL) {
 209 +            bus_nr = hose->bus->subordinate + 1;
 210 +        }
 211 +    }
 212 +    return bus_nr;
 213 +}
 214 +EXPORT_SYMBOL(pcibios_1st_host_bus_nr);
 215 +
 216  static int pcibios_enable_resources(struct pci_dev *dev, int mask)
 217  {
 218         u16 cmd, old_cmd;
 219 diff --git a/arch/mips/pci/pcie-lantiq-msi.c b/arch/mips/pci/pcie-lantiq-msi.c
 220 new file mode 100644
 221 index 0000000..9cbf639
 222 --- /dev/null
 223 +++ b/arch/mips/pci/pcie-lantiq-msi.c
 224 @@ -0,0 +1,399 @@
 225 +/******************************************************************************
 226 +**
 227 +** FILE NAME    : ifxmips_pcie_msi.c
 228 +** PROJECT      : IFX UEIP for VRX200
 229 +** MODULES      : PCI MSI sub module
 230 +**
 231 +** DATE         : 02 Mar 2009
 232 +** AUTHOR       : Lei Chuanhua
 233 +** DESCRIPTION  : PCIe MSI Driver
 234 +** COPYRIGHT    :       Copyright (c) 2009
 235 +**                      Infineon Technologies AG
 236 +**                      Am Campeon 1-12, 85579 Neubiberg, Germany
 237 +**
 238 +**    This program is free software; you can redistribute it and/or modify
 239 +**    it under the terms of the GNU General Public License as published by
 240 +**    the Free Software Foundation; either version 2 of the License, or
 241 +**    (at your option) any later version.
 242 +** HISTORY
 243 +** $Date        $Author         $Comment
 244 +** 02 Mar,2009  Lei Chuanhua    Initial version
 245 +*******************************************************************************/
 246 +/*!
 247 + \defgroup IFX_PCIE_MSI MSI OS APIs
 248 + \ingroup IFX_PCIE
 249 + \brief PCIe bus driver OS interface functions
 250 +*/
 251 +
 252 +/*!
 253 + \file ifxmips_pcie_msi.c
 254 + \ingroup IFX_PCIE
 255 + \brief PCIe MSI OS interface file
 256 +*/
 257 +
 258 +#include <linux/init.h>
 259 +#include <linux/sched.h>
 260 +#include <linux/slab.h>
 261 +#include <linux/interrupt.h>
 262 +#include <linux/kernel_stat.h>
 263 +#include <linux/pci.h>
 264 +#include <linux/msi.h>
 265 +#include <linux/module.h>
 266 +#include <asm/bootinfo.h>
 267 +#include <asm/irq.h>
 268 +#include <asm/traps.h>
 269 +
 270 +#include "pcie-lantiq.h"
 271 +
 272 +#define IFX_MSI_IRQ_NUM    16
 273 +#define SM(_v, _f)             (((_v) << _f##_S) & (_f))
 274 +
 275 +#define IFX_MSI_PIC_REG_BASE                    (KSEG1 | 0x1F700000)
 276 +#define IFX_PCIE_MSI_IR0                (INT_NUM_IM4_IRL0 + 27)
 277 +#define IFX_PCIE_MSI_IR1                (INT_NUM_IM4_IRL0 + 28)
 278 +#define IFX_PCIE_MSI_IR2                (INT_NUM_IM4_IRL0 + 29)
 279 +#define IFX_PCIE_MSI_IR3                (INT_NUM_IM0_IRL0 + 30)
 280 +
 281 +#define IFX_MSI_PCI_INT_DISABLE                 0x80000000
 282 +#define IFX_MSI_PIC_INT_LINE                    0x30000000
 283 +#define IFX_MSI_PIC_MSG_ADDR                    0x0FFF0000
 284 +#define IFX_MSI_PIC_MSG_DATA                    0x0000FFFF
 285 +#define IFX_MSI_PIC_BIG_ENDIAN                  1
 286 +#define IFX_MSI_PIC_INT_LINE_S                  28
 287 +#define IFX_MSI_PIC_MSG_ADDR_S                  16
 288 +#define IFX_MSI_PIC_MSG_DATA_S                  0x0
 289 +
 290 +enum {
 291 +    IFX_PCIE_MSI_IDX0 = 0,
 292 +    IFX_PCIE_MSI_IDX1,
 293 +    IFX_PCIE_MSI_IDX2,
 294 +    IFX_PCIE_MSI_IDX3,
 295 +};
 296 +
 297 +typedef struct ifx_msi_irq_idx {
 298 +    const int irq;
 299 +    const int idx;
 300 +}ifx_msi_irq_idx_t;
 301 +
 302 +struct ifx_msi_pic {
 303 +    volatile u32  pic_table[IFX_MSI_IRQ_NUM];
 304 +    volatile u32  pic_endian;    /* 0x40  */
 305 +};
 306 +typedef struct ifx_msi_pic *ifx_msi_pic_t;
 307 +
 308 +typedef struct ifx_msi_irq {
 309 +    const volatile ifx_msi_pic_t msi_pic_p;
 310 +    const u32 msi_phy_base;
 311 +    const ifx_msi_irq_idx_t msi_irq_idx[IFX_MSI_IRQ_NUM];
 312 +    /*
 313 +     * Each bit in msi_free_irq_bitmask represents a MSI interrupt that is
 314 +     * in use.
 315 +     */
 316 +    u16 msi_free_irq_bitmask;
 317 +
 318 +    /*
 319 +     * Each bit in msi_multiple_irq_bitmask tells that the device using
 320 +     * this bit in msi_free_irq_bitmask is also using the next bit. This
 321 +     * is used so we can disable all of the MSI interrupts when a device
 322 +     * uses multiple.
 323 +     */
 324 +    u16 msi_multiple_irq_bitmask;
 325 +}ifx_msi_irq_t;
 326 +
 327 +static ifx_msi_irq_t msi_irqs[IFX_PCIE_CORE_NR] = {
 328 +    {
 329 +        .msi_pic_p = (const volatile ifx_msi_pic_t)IFX_MSI_PIC_REG_BASE,
 330 +        .msi_phy_base = PCIE_MSI_PHY_BASE,
 331 +        .msi_irq_idx = {
 332 +            {IFX_PCIE_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE_MSI_IR1, IFX_PCIE_MSI_IDX1},
 333 +            {IFX_PCIE_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE_MSI_IR3, IFX_PCIE_MSI_IDX3},
 334 +            {IFX_PCIE_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE_MSI_IR1, IFX_PCIE_MSI_IDX1},
 335 +            {IFX_PCIE_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE_MSI_IR3, IFX_PCIE_MSI_IDX3},
 336 +            {IFX_PCIE_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE_MSI_IR1, IFX_PCIE_MSI_IDX1},
 337 +            {IFX_PCIE_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE_MSI_IR3, IFX_PCIE_MSI_IDX3},
 338 +            {IFX_PCIE_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE_MSI_IR1, IFX_PCIE_MSI_IDX1},
 339 +            {IFX_PCIE_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE_MSI_IR3, IFX_PCIE_MSI_IDX3},
 340 +        },
 341 +        .msi_free_irq_bitmask = 0,
 342 +        .msi_multiple_irq_bitmask= 0,
 343 +    },
 344 +#ifdef CONFIG_IFX_PCIE_2ND_CORE
 345 +    {
 346 +        .msi_pic_p = (const volatile ifx_msi_pic_t)IFX_MSI1_PIC_REG_BASE,
 347 +        .msi_phy_base = PCIE1_MSI_PHY_BASE,
 348 +        .msi_irq_idx = {
 349 +            {IFX_PCIE1_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE1_MSI_IR1, IFX_PCIE_MSI_IDX1},
 350 +            {IFX_PCIE1_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE1_MSI_IR3, IFX_PCIE_MSI_IDX3},
 351 +            {IFX_PCIE1_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE1_MSI_IR1, IFX_PCIE_MSI_IDX1},
 352 +            {IFX_PCIE1_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE1_MSI_IR3, IFX_PCIE_MSI_IDX3},
 353 +            {IFX_PCIE1_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE1_MSI_IR1, IFX_PCIE_MSI_IDX1},
 354 +            {IFX_PCIE1_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE1_MSI_IR3, IFX_PCIE_MSI_IDX3},
 355 +            {IFX_PCIE1_MSI_IR0, IFX_PCIE_MSI_IDX0}, {IFX_PCIE1_MSI_IR1, IFX_PCIE_MSI_IDX1},
 356 +            {IFX_PCIE1_MSI_IR2, IFX_PCIE_MSI_IDX2}, {IFX_PCIE1_MSI_IR3, IFX_PCIE_MSI_IDX3},
 357 +        },
 358 +        .msi_free_irq_bitmask = 0,
 359 +        .msi_multiple_irq_bitmask= 0,
 360 +
 361 +    },
 362 +#endif /* CONFIG_IFX_PCIE_2ND_CORE */
 363 +};
 364 +
 365 +/*
 366 + * This lock controls updates to msi_free_irq_bitmask,
 367 + * msi_multiple_irq_bitmask and pic register settting
 368 + */
 369 +static DEFINE_SPINLOCK(ifx_pcie_msi_lock);
 370 +
 371 +void pcie_msi_pic_init(int pcie_port)
 372 +{
 373 +    spin_lock(&ifx_pcie_msi_lock);
 374 +    msi_irqs[pcie_port].msi_pic_p->pic_endian = IFX_MSI_PIC_BIG_ENDIAN;
 375 +    spin_unlock(&ifx_pcie_msi_lock);
 376 +}
 377 +
 378 +/**
 379 + * \fn int arch_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
 380 + * \brief Called when a driver request MSI interrupts instead of the
 381 + * legacy INT A-D. This routine will allocate multiple interrupts
 382 + * for MSI devices that support them. A device can override this by
 383 + * programming the MSI control bits [6:4] before calling
 384 + * pci_enable_msi().
 385 + *
 386 + * \param[in] pdev   Device requesting MSI interrupts
 387 + * \param[in] desc   MSI descriptor
 388 + *
 389 + * \return   -EINVAL Invalid pcie root port or invalid msi bit
 390 + * \return    0        OK
 391 + * \ingroup IFX_PCIE_MSI
 392 + */
 393 +int
 394 +arch_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
 395 +{
 396 +    int  irq, pos;
 397 +    u16  control;
 398 +    int  irq_idx;
 399 +    int  irq_step;
 400 +    int configured_private_bits;
 401 +    int request_private_bits;
 402 +    struct msi_msg msg;
 403 +    u16 search_mask;
 404 +    struct ifx_pci_controller *ctrl = pdev->bus->sysdata;
 405 +    int pcie_port = ctrl->port;
 406 +
 407 +    IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s %s enter\n", __func__, pci_name(pdev));
 408 +
 409 +    /* XXX, skip RC MSI itself */
 410 +    if (pdev->pcie_type == PCI_EXP_TYPE_ROOT_PORT) {
 411 +        IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s RC itself doesn't use MSI interrupt\n", __func__);
 412 +        return -EINVAL;
 413 +    }
 414 +
 415 +    /*
 416 +     * Read the MSI config to figure out how many IRQs this device
 417 +     * wants.  Most devices only want 1, which will give
 418 +     * configured_private_bits and request_private_bits equal 0.
 419 +     */
 420 +    pci_read_config_word(pdev, desc->msi_attrib.pos + PCI_MSI_FLAGS, &control);
 421 +
 422 +    /*
 423 +     * If the number of private bits has been configured then use
 424 +     * that value instead of the requested number. This gives the
 425 +     * driver the chance to override the number of interrupts
 426 +     * before calling pci_enable_msi().
 427 +     */
 428 +    configured_private_bits = (control & PCI_MSI_FLAGS_QSIZE) >> 4;
 429 +    if (configured_private_bits == 0) {
 430 +        /* Nothing is configured, so use the hardware requested size */
 431 +        request_private_bits = (control & PCI_MSI_FLAGS_QMASK) >> 1;
 432 +    }
 433 +    else {
 434 +        /*
 435 +         * Use the number of configured bits, assuming the
 436 +         * driver wanted to override the hardware request
 437 +         * value.
 438 +         */
 439 +        request_private_bits = configured_private_bits;
 440 +    }
 441 +
 442 +    /*
 443 +     * The PCI 2.3 spec mandates that there are at most 32
 444 +     * interrupts. If this device asks for more, only give it one.
 445 +     */
 446 +    if (request_private_bits > 5) {
 447 +        request_private_bits = 0;
 448 +    }
 449 +again:
 450 +    /*
 451 +     * The IRQs have to be aligned on a power of two based on the
 452 +     * number being requested.
 453 +     */
 454 +    irq_step = (1 << request_private_bits);
 455 +
 456 +    /* Mask with one bit for each IRQ */
 457 +    search_mask = (1 << irq_step) - 1;
 458 +
 459 +    /*
 460 +     * We're going to search msi_free_irq_bitmask_lock for zero
 461 +     * bits. This represents an MSI interrupt number that isn't in
 462 +     * use.
 463 +     */
 464 +    spin_lock(&ifx_pcie_msi_lock);
 465 +    for (pos = 0; pos < IFX_MSI_IRQ_NUM; pos += irq_step) {
 466 +        if ((msi_irqs[pcie_port].msi_free_irq_bitmask & (search_mask << pos)) == 0) {
 467 +            msi_irqs[pcie_port].msi_free_irq_bitmask |= search_mask << pos;
 468 +            msi_irqs[pcie_port].msi_multiple_irq_bitmask |= (search_mask >> 1) << pos;
 469 +            break;
 470 +        }
 471 +    }
 472 +    spin_unlock(&ifx_pcie_msi_lock);
 473 +
 474 +    /* Make sure the search for available interrupts didn't fail */
 475 +    if (pos >= IFX_MSI_IRQ_NUM) {
 476 +        if (request_private_bits) {
 477 +            IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s: Unable to find %d free "
 478 +                  "interrupts, trying just one", __func__, 1 << request_private_bits);
 479 +            request_private_bits = 0;
 480 +            goto again;
 481 +        }
 482 +        else {
 483 +            printk(KERN_ERR "%s: Unable to find a free MSI interrupt\n", __func__);
 484 +            return -EINVAL;
 485 +        }
 486 +    }
 487 +    irq = msi_irqs[pcie_port].msi_irq_idx[pos].irq;
 488 +    irq_idx = msi_irqs[pcie_port].msi_irq_idx[pos].idx;
 489 +
 490 +    IFX_PCIE_PRINT(PCIE_MSG_MSI, "pos %d, irq %d irq_idx %d\n", pos, irq, irq_idx);
 491 +
 492 +    /*
 493 +     * Initialize MSI. This has to match the memory-write endianess from the device
 494 +     * Address bits [23:12]
 495 +     */
 496 +    spin_lock(&ifx_pcie_msi_lock);
 497 +    msi_irqs[pcie_port].msi_pic_p->pic_table[pos] = SM(irq_idx, IFX_MSI_PIC_INT_LINE) |
 498 +                    SM((msi_irqs[pcie_port].msi_phy_base >> 12), IFX_MSI_PIC_MSG_ADDR) |
 499 +                    SM((1 << pos), IFX_MSI_PIC_MSG_DATA);
 500 +
 501 +    /* Enable this entry */
 502 +    msi_irqs[pcie_port].msi_pic_p->pic_table[pos] &= ~IFX_MSI_PCI_INT_DISABLE;
 503 +    spin_unlock(&ifx_pcie_msi_lock);
 504 +
 505 +    IFX_PCIE_PRINT(PCIE_MSG_MSI, "pic_table[%d]: 0x%08x\n",
 506 +        pos, msi_irqs[pcie_port].msi_pic_p->pic_table[pos]);
 507 +
 508 +    /* Update the number of IRQs the device has available to it */
 509 +    control &= ~PCI_MSI_FLAGS_QSIZE;
 510 +    control |= (request_private_bits << 4);
 511 +    pci_write_config_word(pdev, desc->msi_attrib.pos + PCI_MSI_FLAGS, control);
 512 +
 513 +    irq_set_msi_desc(irq, desc);
 514 +    msg.address_hi = 0x0;
 515 +    msg.address_lo = msi_irqs[pcie_port].msi_phy_base;
 516 +    msg.data = SM((1 << pos), IFX_MSI_PIC_MSG_DATA);
 517 +    IFX_PCIE_PRINT(PCIE_MSG_MSI, "msi_data: pos %d 0x%08x\n", pos, msg.data);
 518 +
 519 +    write_msi_msg(irq, &msg);
 520 +    IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s exit\n", __func__);
 521 +    return 0;
 522 +}
 523 +
 524 +static int
 525 +pcie_msi_irq_to_port(unsigned int irq, int *port)
 526 +{
 527 +    int ret = 0;
 528 +
 529 +    if (irq == IFX_PCIE_MSI_IR0 || irq == IFX_PCIE_MSI_IR1 ||
 530 +        irq == IFX_PCIE_MSI_IR2 || irq == IFX_PCIE_MSI_IR3) {
 531 +        *port = IFX_PCIE_PORT0;
 532 +    }
 533 +#ifdef CONFIG_IFX_PCIE_2ND_CORE
 534 +    else if (irq == IFX_PCIE1_MSI_IR0 || irq == IFX_PCIE1_MSI_IR1 ||
 535 +        irq == IFX_PCIE1_MSI_IR2 || irq == IFX_PCIE1_MSI_IR3) {
 536 +        *port = IFX_PCIE_PORT1;
 537 +    }
 538 +#endif /* CONFIG_IFX_PCIE_2ND_CORE */
 539 +    else {
 540 +        printk(KERN_ERR "%s: Attempted to teardown illegal "
 541 +            "MSI interrupt (%d)\n", __func__, irq);
 542 +        ret = -EINVAL;
 543 +    }
 544 +    return ret;
 545 +}
 546 +
 547 +/**
 548 + * \fn void arch_teardown_msi_irq(unsigned int irq)
 549 + * \brief Called when a device no longer needs its MSI interrupts. All
 550 + * MSI interrupts for the device are freed.
 551 + *
 552 + * \param irq   The devices first irq number. There may be multple in sequence.
 553 + * \return none
 554 + * \ingroup IFX_PCIE_MSI
 555 + */
 556 +void
 557 +arch_teardown_msi_irq(unsigned int irq)
 558 +{
 559 +    int pos;
 560 +    int number_irqs;
 561 +    u16 bitmask;
 562 +    int pcie_port;
 563 +
 564 +    IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s enter\n", __func__);
 565 +
 566 +    BUG_ON(irq > (INT_NUM_IM4_IRL0 + 31));
 567 +
 568 +    if (pcie_msi_irq_to_port(irq, &pcie_port) != 0) {
 569 +        return;
 570 +    }
 571 +
 572 +    /* Shift the mask to the correct bit location, not always correct
 573 +     * Probally, the first match will be chosen.
 574 +     */
 575 +    for (pos = 0; pos < IFX_MSI_IRQ_NUM; pos++) {
 576 +        if ((msi_irqs[pcie_port].msi_irq_idx[pos].irq == irq)
 577 +            && (msi_irqs[pcie_port].msi_free_irq_bitmask & ( 1 << pos))) {
 578 +            break;
 579 +        }
 580 +    }
 581 +    if (pos >= IFX_MSI_IRQ_NUM) {
 582 +        printk(KERN_ERR "%s: Unable to find a matched MSI interrupt\n", __func__);
 583 +        return;
 584 +    }
 585 +    spin_lock(&ifx_pcie_msi_lock);
 586 +    /* Disable this entry */
 587 +    msi_irqs[pcie_port].msi_pic_p->pic_table[pos] |= IFX_MSI_PCI_INT_DISABLE;
 588 +    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);
 589 +    spin_unlock(&ifx_pcie_msi_lock);
 590 +    /*
 591 +     * Count the number of IRQs we need to free by looking at the
 592 +     * msi_multiple_irq_bitmask. Each bit set means that the next
 593 +     * IRQ is also owned by this device.
 594 +     */
 595 +    number_irqs = 0;
 596 +    while (((pos + number_irqs) < IFX_MSI_IRQ_NUM) &&
 597 +        (msi_irqs[pcie_port].msi_multiple_irq_bitmask & (1 << (pos + number_irqs)))) {
 598 +        number_irqs++;
 599 +    }
 600 +    number_irqs++;
 601 +
 602 +    /* Mask with one bit for each IRQ */
 603 +    bitmask = (1 << number_irqs) - 1;
 604 +
 605 +    bitmask <<= pos;
 606 +    if ((msi_irqs[pcie_port].msi_free_irq_bitmask & bitmask) != bitmask) {
 607 +        printk(KERN_ERR "%s: Attempted to teardown MSI "
 608 +             "interrupt (%d) not in use\n", __func__, irq);
 609 +        return;
 610 +    }
 611 +    /* Checks are done, update the in use bitmask */
 612 +    spin_lock(&ifx_pcie_msi_lock);
 613 +    msi_irqs[pcie_port].msi_free_irq_bitmask &= ~bitmask;
 614 +    msi_irqs[pcie_port].msi_multiple_irq_bitmask &= ~(bitmask >> 1);
 615 +    spin_unlock(&ifx_pcie_msi_lock);
 616 +    IFX_PCIE_PRINT(PCIE_MSG_MSI, "%s exit\n", __func__);
 617 +}
 618 +
 619 +MODULE_LICENSE("GPL");
 620 +MODULE_AUTHOR("Chuanhua.Lei@infineon.com");
 621 +MODULE_SUPPORTED_DEVICE("Infineon PCIe IP builtin MSI PIC module");
 622 +MODULE_DESCRIPTION("Infineon PCIe IP builtin MSI PIC driver");
 623 +
 624 diff --git a/arch/mips/pci/pcie-lantiq-phy.c b/arch/mips/pci/pcie-lantiq-phy.c
 625 new file mode 100644
 626 index 0000000..9f5027d
 627 --- /dev/null
 628 +++ b/arch/mips/pci/pcie-lantiq-phy.c
 629 @@ -0,0 +1,408 @@
 630 +/******************************************************************************
 631 +**
 632 +** FILE NAME    : ifxmips_pcie_phy.c
 633 +** PROJECT      : IFX UEIP for VRX200
 634 +** MODULES      : PCIe PHY sub module
 635 +**
 636 +** DATE         : 14 May 2009
 637 +** AUTHOR       : Lei Chuanhua
 638 +** DESCRIPTION  : PCIe Root Complex Driver
 639 +** COPYRIGHT    :       Copyright (c) 2009
 640 +**                      Infineon Technologies AG
 641 +**                      Am Campeon 1-12, 85579 Neubiberg, Germany
 642 +**
 643 +**    This program is free software; you can redistribute it and/or modify
 644 +**    it under the terms of the GNU General Public License as published by
 645 +**    the Free Software Foundation; either version 2 of the License, or
 646 +**    (at your option) any later version.
 647 +** HISTORY
 648 +** $Version $Date        $Author         $Comment
 649 +** 0.0.1    14 May,2009  Lei Chuanhua    Initial version
 650 +*******************************************************************************/
 651 +/*!
 652 + \file ifxmips_pcie_phy.c
 653 + \ingroup IFX_PCIE
 654 + \brief PCIe PHY PLL register programming source file
 655 +*/
 656 +#include <linux/types.h>
 657 +#include <linux/kernel.h>
 658 +#include <asm/paccess.h>
 659 +#include <linux/delay.h>
 660 +
 661 +#include "pcie-lantiq.h"
 662 +
 663 +/* PCIe PDI only supports 16 bit operation */
 664 +
 665 +#define IFX_PCIE_PHY_REG_WRITE16(__addr, __data) \
 666 +    ((*(volatile u16 *) (__addr)) = (__data))
 667 +
 668 +#define IFX_PCIE_PHY_REG_READ16(__addr)  \
 669 +    (*(volatile u16 *) (__addr))
 670 +
 671 +#define IFX_PCIE_PHY_REG16(__addr)   \
 672 +    (*(volatile u16 *) (__addr))
 673 +
 674 +#define IFX_PCIE_PHY_REG(__reg, __value, __mask) do { \
 675 +    u16 read_data;                                    \
 676 +    u16 write_data;                                   \
 677 +    read_data = IFX_PCIE_PHY_REG_READ16((__reg));      \
 678 +    write_data = (read_data & ((u16)~(__mask))) | (((u16)(__value)) & ((u16)(__mask)));\
 679 +    IFX_PCIE_PHY_REG_WRITE16((__reg), write_data);               \
 680 +} while (0)
 681 +
 682 +#define IFX_PCIE_PLL_TIMEOUT 1000 /* Tunnable */
 683 +
 684 +static void
 685 +pcie_phy_comm_setup(int pcie_port)
 686 +{
 687 +   /* PLL Setting */
 688 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL1(pcie_port), 0x120e, 0xFFFF);
 689 +
 690 +    /* increase the bias reference voltage */
 691 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x39D7, 0xFFFF);
 692 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x0900, 0xFFFF);
 693 +
 694 +    /* Endcnt */
 695 +    IFX_PCIE_PHY_REG(PCIE_PHY_RX1_EI(pcie_port), 0x0004, 0xFFFF);
 696 +    IFX_PCIE_PHY_REG(PCIE_PHY_RX1_A_CTRL(pcie_port), 0x6803, 0xFFFF);
 697 +
 698 +    /* force */
 699 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL1(pcie_port), 0x0008, 0x0008);
 700 +
 701 +    /* predrv_ser_en */
 702 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX1_A_CTRL2(pcie_port), 0x0706, 0xFFFF);
 703 +
 704 +    /* ctrl_lim */
 705 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL3(pcie_port), 0x1FFF, 0xFFFF);
 706 +
 707 +    /* ctrl */
 708 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX1_A_CTRL1(pcie_port), 0x0800, 0xFF00);
 709 +
 710 +    /* predrv_ser_en */
 711 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX2_A_CTRL2(pcie_port), 0x4702, 0x7F00);
 712 +
 713 +    /* RTERM*/
 714 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL2(pcie_port), 0x2e00, 0xFFFF);
 715 +
 716 +    /* Improved 100MHz clock output  */
 717 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX2_CTRL2(pcie_port), 0x3096, 0xFFFF);
 718 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX2_A_CTRL2(pcie_port), 0x4707, 0xFFFF);
 719 +
 720 +    /* Reduced CDR BW to avoid glitches */
 721 +    IFX_PCIE_PHY_REG(PCIE_PHY_RX1_CDR(pcie_port), 0x0235, 0xFFFF);
 722 +}
 723 +
 724 +#ifdef CONFIG_IFX_PCIE_PHY_36MHZ_MODE
 725 +static void
 726 +pcie_phy_36mhz_mode_setup(int pcie_port)
 727 +{
 728 +    IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d enter\n", __func__, pcie_port);
 729 +
 730 +    /* en_ext_mmd_div_ratio */
 731 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0002);
 732 +
 733 +    /* ext_mmd_div_ratio*/
 734 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0070);
 735 +
 736 +    /* pll_ensdm */
 737 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0200, 0x0200);
 738 +
 739 +    /* en_const_sdm */
 740 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0100, 0x0100);
 741 +
 742 +    /* mmd */
 743 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x2000, 0xe000);
 744 +
 745 +    /* lf_mode */
 746 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x0000, 0x4000);
 747 +
 748 +    /* const_sdm */
 749 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL1(pcie_port), 0x38e4, 0xFFFF);
 750 +
 751 +    /* const sdm */
 752 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x00ee, 0x00FF);
 753 +
 754 +    /* pllmod */
 755 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL7(pcie_port), 0x0002, 0xFFFF);
 756 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL6(pcie_port), 0x3a04, 0xFFFF);
 757 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL5(pcie_port), 0xfae3, 0xFFFF);
 758 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL4(pcie_port), 0x1b72, 0xFFFF);
 759 +
 760 +    IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d exit\n", __func__, pcie_port);
 761 +}
 762 +#endif /* CONFIG_IFX_PCIE_PHY_36MHZ_MODE */
 763 +
 764 +#ifdef CONFIG_IFX_PCIE_PHY_36MHZ_SSC_MODE
 765 +static void
 766 +pcie_phy_36mhz_ssc_mode_setup(int pcie_port)
 767 +{
 768 +    IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d enter\n", __func__, pcie_port);
 769 +
 770 +    /* PLL Setting */
 771 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL1(pcie_port), 0x120e, 0xFFFF);
 772 +
 773 +    /* Increase the bias reference voltage */
 774 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x39D7, 0xFFFF);
 775 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x0900, 0xFFFF);
 776 +
 777 +    /* Endcnt */
 778 +    IFX_PCIE_PHY_REG(PCIE_PHY_RX1_EI(pcie_port), 0x0004, 0xFFFF);
 779 +    IFX_PCIE_PHY_REG(PCIE_PHY_RX1_A_CTRL(pcie_port), 0x6803, 0xFFFF);
 780 +
 781 +    /* Force */
 782 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL1(pcie_port), 0x0008, 0x0008);
 783 +
 784 +    /* Predrv_ser_en */
 785 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX1_A_CTRL2(pcie_port), 0x0706, 0xFFFF);
 786 +
 787 +    /* ctrl_lim */
 788 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL3(pcie_port), 0x1FFF, 0xFFFF);
 789 +
 790 +    /* ctrl */
 791 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX1_A_CTRL1(pcie_port), 0x0800, 0xFF00);
 792 +
 793 +    /* predrv_ser_en */
 794 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX2_A_CTRL2(pcie_port), 0x4702, 0x7F00);
 795 +
 796 +    /* RTERM*/
 797 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL2(pcie_port), 0x2e00, 0xFFFF);
 798 +
 799 +    /* en_ext_mmd_div_ratio */
 800 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0002);
 801 +
 802 +    /* ext_mmd_div_ratio*/
 803 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0070);
 804 +
 805 +    /* pll_ensdm */
 806 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0400, 0x0400);
 807 +
 808 +    /* en_const_sdm */
 809 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0200, 0x0200);
 810 +
 811 +    /* mmd */
 812 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x2000, 0xe000);
 813 +
 814 +    /* lf_mode */
 815 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x0000, 0x4000);
 816 +
 817 +    /* const_sdm */
 818 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL1(pcie_port), 0x38e4, 0xFFFF);
 819 +
 820 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0000, 0x0100);
 821 +    /* const sdm */
 822 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x00ee, 0x00FF);
 823 +
 824 +    /* pllmod */
 825 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL7(pcie_port), 0x0002, 0xFFFF);
 826 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL6(pcie_port), 0x3a04, 0xFFFF);
 827 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL5(pcie_port), 0xfae3, 0xFFFF);
 828 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL4(pcie_port), 0x1c72, 0xFFFF);
 829 +
 830 +    /* improved 100MHz clock output  */
 831 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX2_CTRL2(pcie_port), 0x3096, 0xFFFF);
 832 +    IFX_PCIE_PHY_REG(PCIE_PHY_TX2_A_CTRL2(pcie_port), 0x4707, 0xFFFF);
 833 +
 834 +    /* reduced CDR BW to avoid glitches */
 835 +    IFX_PCIE_PHY_REG(PCIE_PHY_RX1_CDR(pcie_port), 0x0235, 0xFFFF);
 836 +
 837 +    IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d exit\n", __func__, pcie_port);
 838 +}
 839 +#endif /* CONFIG_IFX_PCIE_PHY_36MHZ_SSC_MODE */
 840 +
 841 +#ifdef CONFIG_IFX_PCIE_PHY_25MHZ_MODE
 842 +static void
 843 +pcie_phy_25mhz_mode_setup(int pcie_port)
 844 +{
 845 +    IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d enter\n", __func__, pcie_port);
 846 +    /* en_const_sdm */
 847 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0100, 0x0100);
 848 +
 849 +    /* pll_ensdm */
 850 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0000, 0x0200);
 851 +
 852 +    /* en_ext_mmd_div_ratio*/
 853 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0002, 0x0002);
 854 +
 855 +    /* ext_mmd_div_ratio*/
 856 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0040, 0x0070);
 857 +
 858 +    /* mmd */
 859 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x6000, 0xe000);
 860 +
 861 +    /* lf_mode */
 862 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x4000, 0x4000);
 863 +
 864 +    IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d exit\n", __func__, pcie_port);
 865 +}
 866 +#endif /* CONFIG_IFX_PCIE_PHY_25MHZ_MODE */
 867 +
 868 +#ifdef CONFIG_IFX_PCIE_PHY_100MHZ_MODE
 869 +static void
 870 +pcie_phy_100mhz_mode_setup(int pcie_port)
 871 +{
 872 +    IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d enter\n", __func__, pcie_port);
 873 +    /* en_ext_mmd_div_ratio */
 874 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0002);
 875 +
 876 +    /* ext_mmd_div_ratio*/
 877 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL3(pcie_port), 0x0000, 0x0070);
 878 +
 879 +    /* pll_ensdm */
 880 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0200, 0x0200);
 881 +
 882 +    /* en_const_sdm */
 883 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x0100, 0x0100);
 884 +
 885 +    /* mmd */
 886 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL3(pcie_port), 0x2000, 0xe000);
 887 +
 888 +    /* lf_mode */
 889 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_A_CTRL2(pcie_port), 0x0000, 0x4000);
 890 +
 891 +    /* const_sdm */
 892 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL1(pcie_port), 0x38e4, 0xFFFF);
 893 +
 894 +    /* const sdm */
 895 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL2(pcie_port), 0x00ee, 0x00FF);
 896 +
 897 +    /* pllmod */
 898 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL7(pcie_port), 0x0002, 0xFFFF);
 899 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL6(pcie_port), 0x3a04, 0xFFFF);
 900 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL5(pcie_port), 0xfae3, 0xFFFF);
 901 +    IFX_PCIE_PHY_REG(PCIE_PHY_PLL_CTRL4(pcie_port), 0x1b72, 0xFFFF);
 902 +
 903 +    IFX_PCIE_PRINT(PCIE_MSG_PHY, "%s pcie_port %d exit\n", __func__, pcie_port);
 904 +}
 905 +#endif /* CONFIG_IFX_PCIE_PHY_100MHZ_MODE */
 906 +
 907 +static int
 908 +pcie_phy_wait_startup_ready(int pcie_port)
 909 +{
 910 +    int i;
 911 +
 912 +    for (i = 0; i < IFX_PCIE_PLL_TIMEOUT; i++) {
 913 +        if ((IFX_PCIE_PHY_REG16(PCIE_PHY_PLL_STATUS(pcie_port)) & 0x0040) != 0) {
 914 +            break;
 915 +        }
 916 +        udelay(10);
 917 +    }
 918 +    if (i >= IFX_PCIE_PLL_TIMEOUT) {
 919 +        printk(KERN_ERR "%s PLL Link timeout\n", __func__);
 920 +        return -1;
 921 +    }
 922 +    return 0;
 923 +}
 924 +
 925 +static void
 926 +pcie_phy_load_enable(int pcie_port, int slice)
 927 +{
 928 +    /* Set the load_en of tx/rx slice to '1' */
 929 +    switch (slice) {
 930 +        case 1:
 931 +            IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL1(pcie_port), 0x0010, 0x0010);
 932 +            break;
 933 +        case 2:
 934 +            IFX_PCIE_PHY_REG(PCIE_PHY_TX2_CTRL1(pcie_port), 0x0010, 0x0010);
 935 +            break;
 936 +        case 3:
 937 +            IFX_PCIE_PHY_REG(PCIE_PHY_RX1_CTRL1(pcie_port), 0x0002, 0x0002);
 938 +            break;
 939 +    }
 940 +}
 941 +
 942 +static void
 943 +pcie_phy_load_disable(int pcie_port, int slice)
 944 +{
 945 +    /* set the load_en of tx/rx slice to '0' */
 946 +    switch (slice) {
 947 +        case 1:
 948 +            IFX_PCIE_PHY_REG(PCIE_PHY_TX1_CTRL1(pcie_port), 0x0000, 0x0010);
 949 +            break;
 950 +        case 2:
 951 +            IFX_PCIE_PHY_REG(PCIE_PHY_TX2_CTRL1(pcie_port), 0x0000, 0x0010);
 952 +            break;
 953 +        case 3:
 954 +            IFX_PCIE_PHY_REG(PCIE_PHY_RX1_CTRL1(pcie_port), 0x0000, 0x0002);
 955 +            break;
 956 +    }
 957 +}
 958 +
 959 +static void pcie_phy_load_war(int pcie_port)
 960 +{
 961 +       int slice;
 962 +
 963 +       for (slice = 1; slice < 4; slice++) {
 964 +               pcie_phy_load_enable(pcie_port, slice);
 965 +               udelay(1);
 966 +               pcie_phy_load_disable(pcie_port, slice);
 967 +       }
 968 +}
 969 +
 970 +static void pcie_phy_tx2_modulation(int pcie_port)
 971 +{
 972 +       IFX_PCIE_PHY_REG(PCIE_PHY_TX2_MOD1(pcie_port), 0x1FFE, 0xFFFF);
 973 +       IFX_PCIE_PHY_REG(PCIE_PHY_TX2_MOD2(pcie_port), 0xFFFE, 0xFFFF);
 974 +       IFX_PCIE_PHY_REG(PCIE_PHY_TX2_MOD3(pcie_port), 0x0601, 0xFFFF);
 975 +       mdelay(1);
 976 +       IFX_PCIE_PHY_REG(PCIE_PHY_TX2_MOD3(pcie_port), 0x0001, 0xFFFF);
 977 +}
 978 +
 979 +static void pcie_phy_tx1_modulation(int pcie_port)
 980 +{
 981 +       IFX_PCIE_PHY_REG(PCIE_PHY_TX1_MOD1(pcie_port), 0x1FFE, 0xFFFF);
 982 +       IFX_PCIE_PHY_REG(PCIE_PHY_TX1_MOD2(pcie_port), 0xFFFE, 0xFFFF);
 983 +       IFX_PCIE_PHY_REG(PCIE_PHY_TX1_MOD3(pcie_port), 0x0601, 0xFFFF);
 984 +       mdelay(1);
 985 +       IFX_PCIE_PHY_REG(PCIE_PHY_TX1_MOD3(pcie_port), 0x0001, 0xFFFF);
 986 +}
 987 +
 988 +static void pcie_phy_tx_modulation_war(int pcie_port)
 989 +{
 990 +       int i;
 991 +#define PCIE_PHY_MODULATION_NUM 5
 992 +       for (i = 0; i < PCIE_PHY_MODULATION_NUM; i++) {
 993 +               pcie_phy_tx2_modulation(pcie_port);
 994 +               pcie_phy_tx1_modulation(pcie_port);
 995 +       }
 996 +#undef PCIE_PHY_MODULATION_NUM
 997 +}
 998 +
 999 +void pcie_phy_clock_mode_setup(int pcie_port)
1000 +{
1001 +       pcie_pdi_big_endian(pcie_port);
1002 +
1003 +       /* Enable PDI to access PCIe PHY register */
1004 +       pcie_pdi_pmu_enable(pcie_port);
1005 +
1006 +       /* Configure PLL and PHY clock */
1007 +       pcie_phy_comm_setup(pcie_port);
1008 +
1009 +#ifdef CONFIG_IFX_PCIE_PHY_36MHZ_MODE
1010 +       pcie_phy_36mhz_mode_setup(pcie_port);
1011 +#elif defined(CONFIG_IFX_PCIE_PHY_36MHZ_SSC_MODE)
1012 +       pcie_phy_36mhz_ssc_mode_setup(pcie_port);
1013 +#elif defined(CONFIG_IFX_PCIE_PHY_25MHZ_MODE)
1014 +       pcie_phy_25mhz_mode_setup(pcie_port);
1015 +#elif defined (CONFIG_IFX_PCIE_PHY_100MHZ_MODE)
1016 +       pcie_phy_100mhz_mode_setup(pcie_port);
1017 +#else
1018 +       #error "PCIE PHY Clock Mode must be chosen first!!!!"
1019 +#endif /* CONFIG_IFX_PCIE_PHY_36MHZ_MODE */
1020 +
1021 +       /* Enable PCIe PHY and make PLL setting take effect */
1022 +       pcie_phy_pmu_enable(pcie_port);
1023 +
1024 +       /* Check if we are in startup_ready status */
1025 +       pcie_phy_wait_startup_ready(pcie_port);
1026 +
1027 +       pcie_phy_load_war(pcie_port);
1028 +
1029 +       /* Apply TX modulation workarounds */
1030 +       pcie_phy_tx_modulation_war(pcie_port);
1031 +
1032 +#ifdef IFX_PCI_PHY_REG_DUMP
1033 +       IFX_PCIE_PRINT(PCIE_MSG_PHY, "Modified PHY register dump\n");
1034 +       pcie_phy_reg_dump(pcie_port);
1035 +#endif
1036 +}
1037 +
1038 diff --git a/arch/mips/pci/pcie-lantiq.c b/arch/mips/pci/pcie-lantiq.c
1039 new file mode 100644
1040 index 0000000..1df55b5
1041 --- /dev/null
1042 +++ b/arch/mips/pci/pcie-lantiq.c
1043 @@ -0,0 +1,1146 @@
1044 +#include <linux/types.h>
1045 +#include <linux/module.h>
1046 +#include <linux/pci.h>
1047 +#include <linux/kernel.h>
1048 +#include <linux/init.h>
1049 +#include <linux/delay.h>
1050 +#include <linux/mm.h>
1051 +#include <asm/paccess.h>
1052 +#include <linux/pci.h>
1053 +#include <linux/pci_regs.h>
1054 +#include <linux/platform_device.h>
1055 +
1056 +#define CONFIG_IFX_PCIE_1ST_CORE
1057 +
1058 +#include "pcie-lantiq.h"
1059 +
1060 +#define IFX_PCIE_IR                     (INT_NUM_IM4_IRL0 + 25)
1061 +#define IFX_PCIE_INTA                   (INT_NUM_IM4_IRL0 + 8)
1062 +#define IFX_PCIE_INTB                   (INT_NUM_IM4_IRL0 + 9)
1063 +#define IFX_PCIE_INTC                   (INT_NUM_IM4_IRL0 + 10)
1064 +#define IFX_PCIE_INTD                   (INT_NUM_IM4_IRL0 + 11)
1065 +#define MS(_v, _f)  (((_v) & (_f)) >> _f##_S)
1066 +#define SM(_v, _f)  (((_v) << _f##_S) & (_f))
1067 +#define IFX_REG_SET_BIT(_f, _r) \
1068 +    IFX_REG_W32((IFX_REG_R32((_r)) &~ (_f)) | (_f), (_r))
1069 +#define IFX_PCIE_LTSSM_ENABLE_TIMEOUT 10
1070 +#define IFX_PCIE_PHY_LINK_UP_TIMEOUT  1000
1071 +#define IFX_PCIE_PHY_LOOP_CNT  5
1072 +
1073 +static DEFINE_SPINLOCK(ifx_pcie_lock);
1074 +
1075 +int pcibios_1st_host_bus_nr(void);
1076 +
1077 +unsigned int g_pcie_debug_flag = PCIE_MSG_ANY & (~PCIE_MSG_CFG);
1078 +
1079 +static ifx_pcie_irq_t pcie_irqs[IFX_PCIE_CORE_NR] = {
1080 +    {
1081 +        .ir_irq = {
1082 +            .irq  = IFX_PCIE_IR,
1083 +            .name = "ifx_pcie_rc0",
1084 +        },
1085 +
1086 +        .legacy_irq = {
1087 +            {
1088 +                .irq_bit = PCIE_IRN_INTA,
1089 +                .irq     = IFX_PCIE_INTA,
1090 +            },
1091 +            {
1092 +                .irq_bit = PCIE_IRN_INTB,
1093 +                .irq     = IFX_PCIE_INTB,
1094 +            },
1095 +            {
1096 +                .irq_bit = PCIE_IRN_INTC,
1097 +                .irq     = IFX_PCIE_INTC,
1098 +            },
1099 +            {
1100 +                .irq_bit = PCIE_IRN_INTD,
1101 +                .irq     = IFX_PCIE_INTD,
1102 +            },
1103 +        },
1104 +    },
1105 +};
1106 +
1107 +static inline int pcie_ltssm_enable(int pcie_port)
1108 +{
1109 +       int i;
1110 +
1111 +       IFX_REG_W32(PCIE_RC_CCR_LTSSM_ENABLE, PCIE_RC_CCR(pcie_port)); /* Enable LTSSM */
1112 +
1113 +       /* Wait for the link to come up */
1114 +       for (i = 0; i < IFX_PCIE_LTSSM_ENABLE_TIMEOUT; i++) {
1115 +               if (!(IFX_REG_R32(PCIE_LCTLSTS(pcie_port)) & PCIE_LCTLSTS_RETRAIN_PENDING)) {
1116 +                       break;
1117 +               }
1118 +               udelay(10);
1119 +       }
1120 +       if (i >= IFX_PCIE_LTSSM_ENABLE_TIMEOUT) {
1121 +               IFX_PCIE_PRINT(PCIE_MSG_INIT, "%s link timeout!!!!!\n", __func__);
1122 +               return -1;
1123 +       }
1124 +       return 0;
1125 +}
1126 +
1127 +static inline void pcie_status_register_clear(int pcie_port)
1128 +{
1129 +       IFX_REG_W32(0, PCIE_RC_DR(pcie_port));
1130 +       IFX_REG_W32(0, PCIE_PCICMDSTS(pcie_port));
1131 +       IFX_REG_W32(0, PCIE_DCTLSTS(pcie_port));
1132 +       IFX_REG_W32(0, PCIE_LCTLSTS(pcie_port));
1133 +       IFX_REG_W32(0, PCIE_SLCTLSTS(pcie_port));
1134 +       IFX_REG_W32(0, PCIE_RSTS(pcie_port));
1135 +       IFX_REG_W32(0, PCIE_UES_R(pcie_port));
1136 +       IFX_REG_W32(0, PCIE_UEMR(pcie_port));
1137 +       IFX_REG_W32(0, PCIE_UESR(pcie_port));
1138 +       IFX_REG_W32(0, PCIE_CESR(pcie_port));
1139 +       IFX_REG_W32(0, PCIE_CEMR(pcie_port));
1140 +       IFX_REG_W32(0, PCIE_RESR(pcie_port));
1141 +       IFX_REG_W32(0, PCIE_PVCCRSR(pcie_port));
1142 +       IFX_REG_W32(0, PCIE_VC0_RSR0(pcie_port));
1143 +       IFX_REG_W32(0, PCIE_TPFCS(pcie_port));
1144 +       IFX_REG_W32(0, PCIE_TNPFCS(pcie_port));
1145 +       IFX_REG_W32(0, PCIE_TCFCS(pcie_port));
1146 +       IFX_REG_W32(0, PCIE_QSR(pcie_port));
1147 +       IFX_REG_W32(0, PCIE_IOBLSECS(pcie_port));
1148 +}
1149 +
1150 +static inline int ifx_pcie_link_up(int pcie_port)
1151 +{
1152 +       return (IFX_REG_R32(PCIE_PHY_SR(pcie_port)) & PCIE_PHY_SR_PHY_LINK_UP) ? 1 : 0;
1153 +}
1154 +
1155 +static inline void pcie_mem_io_setup(int pcie_port)
1156 +{
1157 +       unsigned int reg;
1158 +       /*
1159 +        * BAR[0:1] readonly register
1160 +        * RC contains only minimal BARs for packets mapped to this device
1161 +        * Mem/IO filters defines a range of memory occupied by memory mapped IO devices that
1162 +        * reside on the downstream side fo the bridge.
1163 +        */
1164 +       reg = SM((PCIE_MEM_PHY_PORT_TO_END(pcie_port) >> 20), PCIE_MBML_MEM_LIMIT_ADDR)
1165 +               | SM((PCIE_MEM_PHY_PORT_TO_BASE(pcie_port) >> 20), PCIE_MBML_MEM_BASE_ADDR);
1166 +       IFX_REG_W32(reg, PCIE_MBML(pcie_port));
1167 +
1168 +       /* PCIe_PBML, same as MBML */
1169 +       IFX_REG_W32(IFX_REG_R32(PCIE_MBML(pcie_port)), PCIE_PMBL(pcie_port));
1170 +
1171 +       /* IO Address Range */
1172 +       reg = SM((PCIE_IO_PHY_PORT_TO_END(pcie_port) >> 12), PCIE_IOBLSECS_IO_LIMIT_ADDR)
1173 +               | SM((PCIE_IO_PHY_PORT_TO_BASE(pcie_port) >> 12), PCIE_IOBLSECS_IO_BASE_ADDR);
1174 +       reg |= PCIE_IOBLSECS_32BIT_IO_ADDR;
1175 +               IFX_REG_W32(reg, PCIE_IOBLSECS(pcie_port));
1176 +
1177 +       reg = SM((PCIE_IO_PHY_PORT_TO_END(pcie_port) >> 16), PCIE_IO_BANDL_UPPER_16BIT_IO_LIMIT)
1178 +               | SM((PCIE_IO_PHY_PORT_TO_BASE(pcie_port) >> 16), PCIE_IO_BANDL_UPPER_16BIT_IO_BASE);
1179 +       IFX_REG_W32(reg, PCIE_IO_BANDL(pcie_port));
1180 +}
1181 +
1182 +static inline void pcie_msi_setup(int pcie_port)
1183 +{
1184 +       unsigned int reg;
1185 +
1186 +       /* XXX, MSI stuff should only apply to EP */
1187 +       /* MSI Capability: Only enable 32-bit addresses */
1188 +       reg = IFX_REG_R32(PCIE_MCAPR(pcie_port));
1189 +       reg &= ~PCIE_MCAPR_ADDR64_CAP;
1190 +       reg |= PCIE_MCAPR_MSI_ENABLE;
1191 +
1192 +       /* Disable multiple message */
1193 +       reg &= ~(PCIE_MCAPR_MULTI_MSG_CAP | PCIE_MCAPR_MULTI_MSG_ENABLE);
1194 +       IFX_REG_W32(reg, PCIE_MCAPR(pcie_port));
1195 +}
1196 +
1197 +static inline void pcie_pm_setup(int pcie_port)
1198 +{
1199 +       unsigned int reg;
1200 +
1201 +       /* Enable PME, Soft reset enabled */
1202 +       reg = IFX_REG_R32(PCIE_PM_CSR(pcie_port));
1203 +       reg |= PCIE_PM_CSR_PME_ENABLE | PCIE_PM_CSR_SW_RST;
1204 +       IFX_REG_W32(reg, PCIE_PM_CSR(pcie_port));
1205 +}
1206 +
1207 +static inline void pcie_bus_setup(int pcie_port)
1208 +{
1209 +       unsigned int reg;
1210 +
1211 +       reg = SM(0, PCIE_BNR_PRIMARY_BUS_NUM) | SM(1, PCIE_PNR_SECONDARY_BUS_NUM) | SM(0xFF, PCIE_PNR_SUB_BUS_NUM);
1212 +       IFX_REG_W32(reg, PCIE_BNR(pcie_port));
1213 +}
1214 +
1215 +static inline void pcie_device_setup(int pcie_port)
1216 +{
1217 +       unsigned int reg;
1218 +
1219 +       /* Device capability register, set up Maximum payload size */
1220 +       reg = IFX_REG_R32(PCIE_DCAP(pcie_port));
1221 +       reg |= PCIE_DCAP_ROLE_BASE_ERR_REPORT;
1222 +       reg |= SM(PCIE_MAX_PAYLOAD_128, PCIE_DCAP_MAX_PAYLOAD_SIZE);
1223 +
1224 +       /* Only available for EP */
1225 +       reg &= ~(PCIE_DCAP_EP_L0S_LATENCY | PCIE_DCAP_EP_L1_LATENCY);
1226 +       IFX_REG_W32(reg, PCIE_DCAP(pcie_port));
1227 +
1228 +       /* Device control and status register */
1229 +       /* Set Maximum Read Request size for the device as a Requestor */
1230 +       reg = IFX_REG_R32(PCIE_DCTLSTS(pcie_port));
1231 +
1232 +       /*
1233 +        * Request size can be larger than the MPS used, but the completions returned
1234 +        * for the read will be bounded by the MPS size.
1235 +        * In our system, Max request size depends on AHB burst size. It is 64 bytes.
1236 +        * but we set it as 128 as minimum one.
1237 +        */
1238 +       reg |= SM(PCIE_MAX_PAYLOAD_128, PCIE_DCTLSTS_MAX_READ_SIZE)
1239 +               | SM(PCIE_MAX_PAYLOAD_128, PCIE_DCTLSTS_MAX_PAYLOAD_SIZE);
1240 +
1241 +       /* Enable relaxed ordering, no snoop, and all kinds of errors */
1242 +       reg |= PCIE_DCTLSTS_RELAXED_ORDERING_EN | PCIE_DCTLSTS_ERR_EN | PCIE_DCTLSTS_NO_SNOOP_EN;
1243 +
1244 +       IFX_REG_W32(reg, PCIE_DCTLSTS(pcie_port));
1245 +}
1246 +
1247 +static inline void pcie_link_setup(int pcie_port)
1248 +{
1249 +       unsigned int reg;
1250 +
1251 +       /*
1252 +        * XXX, Link capability register, bit 18 for EP CLKREQ# dynamic clock management for L1, L2/3 CPM
1253 +        * L0s is reported during link training via TS1 order set by N_FTS
1254 +        */
1255 +       reg = IFX_REG_R32(PCIE_LCAP(pcie_port));
1256 +       reg &= ~PCIE_LCAP_L0S_EIXT_LATENCY;
1257 +       reg |= SM(3, PCIE_LCAP_L0S_EIXT_LATENCY);
1258 +       IFX_REG_W32(reg, PCIE_LCAP(pcie_port));
1259 +
1260 +       /* Link control and status register */
1261 +       reg = IFX_REG_R32(PCIE_LCTLSTS(pcie_port));
1262 +
1263 +       /* Link Enable, ASPM enabled  */
1264 +       reg &= ~PCIE_LCTLSTS_LINK_DISABLE;
1265 +
1266 +#ifdef CONFIG_PCIEASPM
1267 +       /*
1268 +        * We use the same physical reference clock that the platform provides on the connector
1269 +        * It paved the way for ASPM to calculate the new exit Latency
1270 +        */
1271 +       reg |= PCIE_LCTLSTS_SLOT_CLK_CFG;
1272 +       reg |= PCIE_LCTLSTS_COM_CLK_CFG;
1273 +       /*
1274 +        * We should disable ASPM by default except that we have dedicated power management support
1275 +        * Enable ASPM will cause the system hangup/instability, performance degration
1276 +        */
1277 +       reg |= PCIE_LCTLSTS_ASPM_ENABLE;
1278 +#else
1279 +       reg &= ~PCIE_LCTLSTS_ASPM_ENABLE;
1280 +#endif /* CONFIG_PCIEASPM */
1281 +
1282 +       /*
1283 +        * The maximum size of any completion with data packet is bounded by the MPS setting
1284 +        * in  device control register
1285 +        */
1286 +       /* RCB may cause multiple split transactions, two options available, we use 64 byte RCB */
1287 +       reg &= ~ PCIE_LCTLSTS_RCB128;
1288 +       IFX_REG_W32(reg, PCIE_LCTLSTS(pcie_port));
1289 +}
1290 +
1291 +static inline void pcie_error_setup(int pcie_port)
1292 +{
1293 +       unsigned int reg;
1294 +
1295 +       /*
1296 +        * Forward ERR_COR, ERR_NONFATAL, ERR_FATAL to the backbone
1297 +        * Poisoned write TLPs and completions indicating poisoned TLPs will set the PCIe_PCICMDSTS.MDPE
1298 +        */
1299 +       reg = IFX_REG_R32(PCIE_INTRBCTRL(pcie_port));
1300 +       reg |= PCIE_INTRBCTRL_SERR_ENABLE | PCIE_INTRBCTRL_PARITY_ERR_RESP_ENABLE;
1301 +
1302 +       IFX_REG_W32(reg, PCIE_INTRBCTRL(pcie_port));
1303 +
1304 +       /* Uncorrectable Error Mask Register, Unmask <enable> all bits in PCIE_UESR */
1305 +       reg = IFX_REG_R32(PCIE_UEMR(pcie_port));
1306 +       reg &= ~PCIE_ALL_UNCORRECTABLE_ERR;
1307 +       IFX_REG_W32(reg, PCIE_UEMR(pcie_port));
1308 +
1309 +       /* Uncorrectable Error Severity Register, ALL errors are FATAL */
1310 +       IFX_REG_W32(PCIE_ALL_UNCORRECTABLE_ERR, PCIE_UESR(pcie_port));
1311 +
1312 +       /* Correctable Error Mask Register, unmask <enable> all bits */
1313 +       reg = IFX_REG_R32(PCIE_CEMR(pcie_port));
1314 +       reg &= ~PCIE_CORRECTABLE_ERR;
1315 +       IFX_REG_W32(reg, PCIE_CEMR(pcie_port));
1316 +
1317 +       /* Advanced Error Capabilities and Control Registr */
1318 +       reg = IFX_REG_R32(PCIE_AECCR(pcie_port));
1319 +       reg |= PCIE_AECCR_ECRC_CHECK_EN | PCIE_AECCR_ECRC_GEN_EN;
1320 +       IFX_REG_W32(reg, PCIE_AECCR(pcie_port));
1321 +
1322 +       /* Root Error Command Register, Report all types of errors */
1323 +       reg = IFX_REG_R32(PCIE_RECR(pcie_port));
1324 +       reg |= PCIE_RECR_ERR_REPORT_EN;
1325 +       IFX_REG_W32(reg, PCIE_RECR(pcie_port));
1326 +
1327 +       /* Clear the Root status register */
1328 +       reg = IFX_REG_R32(PCIE_RESR(pcie_port));
1329 +       IFX_REG_W32(reg, PCIE_RESR(pcie_port));
1330 +}
1331 +
1332 +static inline void pcie_root_setup(int pcie_port)
1333 +{
1334 +       unsigned int reg;
1335 +
1336 +       /* Root control and capabilities register */
1337 +       reg = IFX_REG_R32(PCIE_RCTLCAP(pcie_port));
1338 +       reg |= PCIE_RCTLCAP_SERR_ENABLE | PCIE_RCTLCAP_PME_INT_EN;
1339 +       IFX_REG_W32(reg, PCIE_RCTLCAP(pcie_port));
1340 +}
1341 +
1342 +static inline void pcie_vc_setup(int pcie_port)
1343 +{
1344 +       unsigned int reg;
1345 +
1346 +       /* Port VC Capability Register 2 */
1347 +       reg = IFX_REG_R32(PCIE_PVC2(pcie_port));
1348 +       reg &= ~PCIE_PVC2_VC_ARB_WRR;
1349 +       reg |= PCIE_PVC2_VC_ARB_16P_FIXED_WRR;
1350 +       IFX_REG_W32(reg, PCIE_PVC2(pcie_port));
1351 +
1352 +       /* VC0 Resource Capability Register */
1353 +       reg = IFX_REG_R32(PCIE_VC0_RC(pcie_port));
1354 +       reg &= ~PCIE_VC0_RC_REJECT_SNOOP;
1355 +       IFX_REG_W32(reg, PCIE_VC0_RC(pcie_port));
1356 +}
1357 +
1358 +static inline void pcie_port_logic_setup(int pcie_port)
1359 +{
1360 +       unsigned int reg;
1361 +
1362 +       /* FTS number, default 12, increase to 63, may increase time from/to L0s to L0  */
1363 +       reg = IFX_REG_R32(PCIE_AFR(pcie_port));
1364 +       reg &= ~(PCIE_AFR_FTS_NUM | PCIE_AFR_COM_FTS_NUM);
1365 +       reg |= SM(PCIE_AFR_FTS_NUM_DEFAULT, PCIE_AFR_FTS_NUM)
1366 +               | SM(PCIE_AFR_FTS_NUM_DEFAULT, PCIE_AFR_COM_FTS_NUM);
1367 +       /* L0s and L1 entry latency */
1368 +       reg &= ~(PCIE_AFR_L0S_ENTRY_LATENCY | PCIE_AFR_L1_ENTRY_LATENCY);
1369 +       reg |= SM(PCIE_AFR_L0S_ENTRY_LATENCY_DEFAULT, PCIE_AFR_L0S_ENTRY_LATENCY)
1370 +               | SM(PCIE_AFR_L1_ENTRY_LATENCY_DEFAULT, PCIE_AFR_L1_ENTRY_LATENCY);
1371 +       IFX_REG_W32(reg, PCIE_AFR(pcie_port));
1372 +
1373 +       /* Port Link Control Register */
1374 +       reg = IFX_REG_R32(PCIE_PLCR(pcie_port));
1375 +       reg |= PCIE_PLCR_DLL_LINK_EN;  /* Enable the DLL link */
1376 +       IFX_REG_W32(reg, PCIE_PLCR(pcie_port));
1377 +
1378 +       /* Lane Skew Register */
1379 +       reg = IFX_REG_R32(PCIE_LSR(pcie_port));
1380 +       /* Enable ACK/NACK and FC */
1381 +       reg &= ~(PCIE_LSR_ACKNAK_DISABLE | PCIE_LSR_FC_DISABLE);
1382 +       IFX_REG_W32(reg, PCIE_LSR(pcie_port));
1383 +
1384 +       /* Symbol Timer Register and Filter Mask Register 1 */
1385 +       reg = IFX_REG_R32(PCIE_STRFMR(pcie_port));
1386 +
1387 +       /* Default SKP interval is very accurate already, 5us */
1388 +       /* Enable IO/CFG transaction */
1389 +       reg |= PCIE_STRFMR_RX_CFG_TRANS_ENABLE | PCIE_STRFMR_RX_IO_TRANS_ENABLE;
1390 +       /* Disable FC WDT */
1391 +       reg &= ~PCIE_STRFMR_FC_WDT_DISABLE;
1392 +       IFX_REG_W32(reg, PCIE_STRFMR(pcie_port));
1393 +
1394 +       /* Filter Masker Register 2 */
1395 +       reg = IFX_REG_R32(PCIE_FMR2(pcie_port));
1396 +       reg |= PCIE_FMR2_VENDOR_MSG1_PASSED_TO_TRGT1 | PCIE_FMR2_VENDOR_MSG0_PASSED_TO_TRGT1;
1397 +       IFX_REG_W32(reg, PCIE_FMR2(pcie_port));
1398 +
1399 +       /* VC0 Completion Receive Queue Control Register */
1400 +       reg = IFX_REG_R32(PCIE_VC0_CRQCR(pcie_port));
1401 +       reg &= ~PCIE_VC0_CRQCR_CPL_TLP_QUEUE_MODE;
1402 +       reg |= SM(PCIE_VC0_TLP_QUEUE_MODE_BYPASS, PCIE_VC0_CRQCR_CPL_TLP_QUEUE_MODE);
1403 +       IFX_REG_W32(reg, PCIE_VC0_CRQCR(pcie_port));
1404 +}
1405 +
1406 +static inline void pcie_rc_cfg_reg_setup(int pcie_port)
1407 +{
1408 +       /* diable ltssm */
1409 +       IFX_REG_W32(0, PCIE_RC_CCR(pcie_port));
1410 +
1411 +       pcie_mem_io_setup(pcie_port);
1412 +       pcie_msi_setup(pcie_port);
1413 +       pcie_pm_setup(pcie_port);
1414 +       pcie_bus_setup(pcie_port);
1415 +       pcie_device_setup(pcie_port);
1416 +       pcie_link_setup(pcie_port);
1417 +       pcie_error_setup(pcie_port);
1418 +       pcie_root_setup(pcie_port);
1419 +       pcie_vc_setup(pcie_port);
1420 +       pcie_port_logic_setup(pcie_port);
1421 +}
1422 +
1423 +static int ifx_pcie_wait_phy_link_up(int pcie_port)
1424 +{
1425 +       int i;
1426 +
1427 +       /* Wait for PHY link is up */
1428 +       for (i = 0; i < IFX_PCIE_PHY_LINK_UP_TIMEOUT; i++) {
1429 +               if (ifx_pcie_link_up(pcie_port)) {
1430 +                       break;
1431 +               }
1432 +               udelay(100);
1433 +       }
1434 +       if (i >= IFX_PCIE_PHY_LINK_UP_TIMEOUT) {
1435 +               printk(KERN_ERR "%s timeout\n", __func__);
1436 +               return -1;
1437 +       }
1438 +
1439 +       /* Check data link up or not */
1440 +       if (!(IFX_REG_R32(PCIE_RC_DR(pcie_port)) & PCIE_RC_DR_DLL_UP)) {
1441 +               printk(KERN_ERR "%s DLL link is still down\n", __func__);
1442 +               return -1;
1443 +       }
1444 +
1445 +       /* Check Data link active or not */
1446 +       if (!(IFX_REG_R32(PCIE_LCTLSTS(pcie_port)) & PCIE_LCTLSTS_DLL_ACTIVE)) {
1447 +               printk(KERN_ERR "%s DLL is not active\n", __func__);
1448 +               return -1;
1449 +       }
1450 +       return 0;
1451 +}
1452 +
1453 +static inline int pcie_app_loigc_setup(int pcie_port)
1454 +{
1455 +       IFX_REG_W32(PCIE_AHB_CTRL_BUS_ERROR_SUPPRESS, PCIE_AHB_CTRL(pcie_port));
1456 +
1457 +       /* Pull PCIe EP out of reset */
1458 +       pcie_device_rst_deassert(pcie_port);
1459 +
1460 +       /* Start LTSSM training between RC and EP */
1461 +       pcie_ltssm_enable(pcie_port);
1462 +
1463 +       /* Check PHY status after enabling LTSSM */
1464 +       if (ifx_pcie_wait_phy_link_up(pcie_port) != 0) {
1465 +               return -1;
1466 +       }
1467 +       return 0;
1468 +}
1469 +
1470 +/*
1471 + * Must be done after ltssm due to based on negotiated link
1472 + * width and payload size
1473 + * Update the Replay Time Limit. Empirically, some PCIe
1474 + * devices take a little longer to respond than expected under
1475 + * load. As a workaround for this we configure the Replay Time
1476 + * Limit to the value expected for a 512 byte MPS instead of
1477 + * our actual 128 byte MPS. The numbers below are directly
1478 + * from the PCIe spec table 3-4/5.
1479 + */
1480 +static inline void pcie_replay_time_update(int pcie_port)
1481 +{
1482 +       unsigned int reg;
1483 +       int nlw;
1484 +       int rtl;
1485 +
1486 +       reg = IFX_REG_R32(PCIE_LCTLSTS(pcie_port));
1487 +
1488 +       nlw = MS(reg, PCIE_LCTLSTS_NEGOTIATED_LINK_WIDTH);
1489 +       switch (nlw) {
1490 +       case PCIE_MAX_LENGTH_WIDTH_X1:
1491 +               rtl = 1677;
1492 +               break;
1493 +       case PCIE_MAX_LENGTH_WIDTH_X2:
1494 +               rtl = 867;
1495 +               break;
1496 +       case PCIE_MAX_LENGTH_WIDTH_X4:
1497 +               rtl = 462;
1498 +               break;
1499 +       case PCIE_MAX_LENGTH_WIDTH_X8:
1500 +               rtl = 258;
1501 +               break;
1502 +       default:
1503 +               rtl = 1677;
1504 +               break;
1505 +       }
1506 +       reg = IFX_REG_R32(PCIE_ALTRT(pcie_port));
1507 +       reg &= ~PCIE_ALTRT_REPLAY_TIME_LIMIT;
1508 +       reg |= SM(rtl, PCIE_ALTRT_REPLAY_TIME_LIMIT);
1509 +       IFX_REG_W32(reg, PCIE_ALTRT(pcie_port));
1510 +
1511 +       IFX_PCIE_PRINT(PCIE_MSG_REG, "%s PCIE_ALTRT 0x%08x\n",
1512 +               __func__, IFX_REG_R32(PCIE_ALTRT(pcie_port)));
1513 +}
1514 +
1515 +/*
1516 + * Table 359 Enhanced Configuration Address Mapping1)
1517 + * 1) This table is defined in Table 7-1, page 341, PCI Express Base Specification v1.1
1518 + * Memory Address PCI Express Configuration Space
1519 + * A[(20+n-1):20] Bus Number 1 < n < 8
1520 + * A[19:15] Device Number
1521 + * A[14:12] Function Number
1522 + * A[11:8] Extended Register Number
1523 + * A[7:2] Register Number
1524 + * A[1:0] Along with size of the access, used to generate Byte Enables
1525 + * For VR9, only the address bits [22:0] are mapped to the configuration space:
1526 + * . Address bits [22:20] select the target bus (1-of-8)1)
1527 + * . Address bits [19:15] select the target device (1-of-32) on the bus
1528 + * . Address bits [14:12] select the target function (1-of-8) within the device.
1529 + * . Address bits [11:2] selects the target dword (1-of-1024) within the selected function.s configuration space
1530 + * . Address bits [1:0] define the start byte location within the selected dword.
1531 + */
1532 +static inline unsigned int pcie_bus_addr(u8 bus_num, u16 devfn, int where)
1533 +{
1534 +       unsigned int addr;
1535 +       u8  bus;
1536 +
1537 +       if (!bus_num) {
1538 +               /* type 0 */
1539 +               addr = ((PCI_SLOT(devfn) & 0x1F) << 15) | ((PCI_FUNC(devfn) & 0x7) << 12) | ((where & 0xFFF)& ~3);
1540 +       } else {
1541 +               bus = bus_num;
1542 +               /* type 1, only support 8 buses  */
1543 +               addr = ((bus & 0x7) << 20) | ((PCI_SLOT(devfn) & 0x1F) << 15) |
1544 +                       ((PCI_FUNC(devfn) & 0x7) << 12) | ((where & 0xFFF) & ~3);
1545 +       }
1546 +       IFX_PCIE_PRINT(PCIE_MSG_CFG, "%s: bus addr : %02x:%02x.%01x/%02x, addr=%08x\n",
1547 +               __func__, bus_num, PCI_SLOT(devfn), PCI_FUNC(devfn), where, addr);
1548 +       return addr;
1549 +}
1550 +
1551 +static int pcie_valid_config(int pcie_port, int bus, int dev)
1552 +{
1553 +       /* RC itself */
1554 +       if ((bus == 0) && (dev == 0))
1555 +               return 1;
1556 +
1557 +       /* No physical link */
1558 +       if (!ifx_pcie_link_up(pcie_port))
1559 +               return 0;
1560 +
1561 +       /* Bus zero only has RC itself
1562 +       * XXX, check if EP will be integrated
1563 +       */
1564 +       if ((bus == 0) && (dev != 0))
1565 +               return 0;
1566 +
1567 +       /* Maximum 8 buses supported for VRX */
1568 +       if (bus > 9)
1569 +               return 0;
1570 +
1571 +       /*
1572 +        * PCIe is PtP link, one bus only supports only one device
1573 +        * except bus zero and PCIe switch which is virtual bus device
1574 +        * The following two conditions really depends on the system design
1575 +        * and attached the device.
1576 +        * XXX, how about more new switch
1577 +        */
1578 +       if ((bus == 1) && (dev != 0))
1579 +               return 0;
1580 +
1581 +       if ((bus >= 3) && (dev != 0))
1582 +               return 0;
1583 +       return 1;
1584 +}
1585 +
1586 +static inline unsigned int ifx_pcie_cfg_rd(int pcie_port, unsigned int reg)
1587 +{
1588 +       return IFX_REG_R32((volatile unsigned int *)(PCIE_CFG_PORT_TO_BASE(pcie_port) + reg));
1589 +}
1590 +
1591 +static inline void ifx_pcie_cfg_wr(int pcie_port, unsigned int reg, unsigned int val)
1592 +{
1593 +       IFX_REG_W32( val, (volatile unsigned int *)(PCIE_CFG_PORT_TO_BASE(pcie_port) + reg));
1594 +}
1595 +
1596 +static inline unsigned int ifx_pcie_rc_cfg_rd(int pcie_port, unsigned int reg)
1597 +{
1598 +       return IFX_REG_R32((volatile unsigned int *)(PCIE_RC_PORT_TO_BASE(pcie_port) + reg));
1599 +}
1600 +
1601 +static inline void ifx_pcie_rc_cfg_wr(int pcie_port, unsigned int reg, unsigned int val)
1602 +{
1603 +       IFX_REG_W32(val, (volatile unsigned int *)(PCIE_RC_PORT_TO_BASE(pcie_port) + reg));
1604 +}
1605 +
1606 +unsigned int ifx_pcie_bus_enum_read_hack(int where, unsigned int value)
1607 +{
1608 +       unsigned int tvalue = value;
1609 +
1610 +       if (where == PCI_PRIMARY_BUS) {
1611 +               u8 primary, secondary, subordinate;
1612 +
1613 +               primary = tvalue & 0xFF;
1614 +               secondary = (tvalue >> 8) & 0xFF;
1615 +               subordinate = (tvalue >> 16) & 0xFF;
1616 +               primary += pcibios_1st_host_bus_nr();
1617 +               secondary += pcibios_1st_host_bus_nr();
1618 +               subordinate += pcibios_1st_host_bus_nr();
1619 +               tvalue = (tvalue & 0xFF000000) | (unsigned int)primary | (unsigned int)(secondary << 8) | (unsigned int)(subordinate << 16);
1620 +       }
1621 +       return tvalue;
1622 +}
1623 +
1624 +unsigned int ifx_pcie_bus_enum_write_hack(int where, unsigned int value)
1625 +{
1626 +       unsigned int tvalue = value;
1627 +
1628 +       if (where == PCI_PRIMARY_BUS) {
1629 +               u8 primary, secondary, subordinate;
1630 +
1631 +               primary = tvalue & 0xFF;
1632 +               secondary = (tvalue >> 8) & 0xFF;
1633 +               subordinate = (tvalue >> 16) & 0xFF;
1634 +               if (primary > 0 && primary != 0xFF)
1635 +                       primary -= pcibios_1st_host_bus_nr();
1636 +               if (secondary > 0 && secondary != 0xFF)
1637 +                       secondary -= pcibios_1st_host_bus_nr();
1638 +               if (subordinate > 0 && subordinate != 0xFF)
1639 +                       subordinate -= pcibios_1st_host_bus_nr();
1640 +               tvalue = (tvalue & 0xFF000000) | (unsigned int)primary | (unsigned int)(secondary << 8) | (unsigned int)(subordinate << 16);
1641 +       } else if (where == PCI_SUBORDINATE_BUS) {
1642 +               u8 subordinate = tvalue & 0xFF;
1643 +               subordinate = subordinate > 0 ? subordinate - pcibios_1st_host_bus_nr() : 0;
1644 +               tvalue = subordinate;
1645 +       }
1646 +       return tvalue;
1647 +}
1648 +
1649 +/**
1650 + * \fn static int ifx_pcie_read_config(struct pci_bus *bus, unsigned int devfn,
1651 + *                   int where, int size, unsigned int *value)
1652 + * \brief Read a value from configuration space
1653 + *
1654 + * \param[in] bus    Pointer to pci bus
1655 + * \param[in] devfn  PCI device function number
1656 + * \param[in] where  PCI register number
1657 + * \param[in] size   Register read size
1658 + * \param[out] value    Pointer to return value
1659 + * \return  PCIBIOS_BAD_REGISTER_NUMBER Invalid register number
1660 + * \return  PCIBIOS_FUNC_NOT_SUPPORTED  PCI function not supported
1661 + * \return  PCIBIOS_DEVICE_NOT_FOUND    PCI device not found
1662 + * \return  PCIBIOS_SUCCESSFUL          OK
1663 + * \ingroup IFX_PCIE_OS
1664 + */
1665 +static int ifx_pcie_read_config(struct pci_bus *bus, unsigned int devfn, int where, int size, unsigned int *value)
1666 +{
1667 +       unsigned int data = 0;
1668 +       int bus_number = bus->number;
1669 +       static const unsigned int mask[8] = {0, 0xff, 0xffff, 0, 0xffffffff, 0, 0, 0};
1670 +       int ret = PCIBIOS_SUCCESSFUL;
1671 +       struct ifx_pci_controller *ctrl = bus->sysdata;
1672 +       int pcie_port = ctrl->port;
1673 +
1674 +       if (unlikely(size != 1 && size != 2 && size != 4)){
1675 +               ret = PCIBIOS_BAD_REGISTER_NUMBER;
1676 +               goto out;
1677 +       }
1678 +
1679 +       /* Make sure the address is aligned to natural boundary */
1680 +       if (unlikely(((size - 1) & where))) {
1681 +               ret = PCIBIOS_BAD_REGISTER_NUMBER;
1682 +               goto out;
1683 +       }
1684 +
1685 +       /*
1686 +        * If we are second controller, we have to cheat OS so that it assume
1687 +        * its bus number starts from 0 in host controller
1688 +        */
1689 +       bus_number = ifx_pcie_bus_nr_deduct(bus_number, pcie_port);
1690 +
1691 +       /*
1692 +        * We need to force the bus number to be zero on the root
1693 +        * bus. Linux numbers the 2nd root bus to start after all
1694 +        * busses on root 0.
1695 +        */
1696 +       if (bus->parent == NULL)
1697 +               bus_number = 0;
1698 +
1699 +       /*
1700 +        * PCIe only has a single device connected to it. It is
1701 +        * always device ID 0. Don't bother doing reads for other
1702 +        * device IDs on the first segment.
1703 +        */
1704 +       if ((bus_number == 0) && (PCI_SLOT(devfn) != 0)) {
1705 +               ret = PCIBIOS_FUNC_NOT_SUPPORTED;
1706 +               goto out;
1707 +       }
1708 +
1709 +       if (pcie_valid_config(pcie_port, bus_number, PCI_SLOT(devfn)) == 0) {
1710 +               *value = 0xffffffff;
1711 +               ret = PCIBIOS_DEVICE_NOT_FOUND;
1712 +               goto out;
1713 +       }
1714 +
1715 +       IFX_PCIE_PRINT(PCIE_MSG_READ_CFG, "%s: %02x:%02x.%01x/%02x:%01d\n", __func__, bus_number,
1716 +               PCI_SLOT(devfn), PCI_FUNC(devfn), where, size);
1717 +
1718 +       PCIE_IRQ_LOCK(ifx_pcie_lock);
1719 +       if (bus_number == 0) { /* RC itself */
1720 +               unsigned int t;
1721 +
1722 +               t = (where & ~3);
1723 +               data = ifx_pcie_rc_cfg_rd(pcie_port, t);
1724 +               IFX_PCIE_PRINT(PCIE_MSG_READ_CFG, "%s: rd local cfg, offset:%08x, data:%08x\n",
1725 +                       __func__, t, data);
1726 +       } else {
1727 +               unsigned int addr = pcie_bus_addr(bus_number, devfn, where);
1728 +
1729 +               data = ifx_pcie_cfg_rd(pcie_port, addr);
1730 +               if (pcie_port == IFX_PCIE_PORT0) {
1731 +#ifdef CONFIG_IFX_PCIE_HW_SWAP
1732 +                       data = le32_to_cpu(data);
1733 +#endif /* CONFIG_IFX_PCIE_HW_SWAP */
1734 +               } else {
1735 +#ifdef CONFIG_IFX_PCIE1_HW_SWAP
1736 +                       data = le32_to_cpu(data);
1737 +#endif /* CONFIG_IFX_PCIE_HW_SWAP */
1738 +               }
1739 +       }
1740 +       /* To get a correct PCI topology, we have to restore the bus number to OS */
1741 +       data = ifx_pcie_bus_enum_hack(bus, devfn, where, data, pcie_port, 1);
1742 +
1743 +       PCIE_IRQ_UNLOCK(ifx_pcie_lock);
1744 +       IFX_PCIE_PRINT(PCIE_MSG_READ_CFG, "%s: read config: data=%08x raw=%08x\n",
1745 +               __func__, (data >> (8 * (where & 3))) & mask[size & 7], data);
1746 +
1747 +       *value = (data >> (8 * (where & 3))) & mask[size & 7];
1748 +out:
1749 +       return ret;
1750 +}
1751 +
1752 +static unsigned int ifx_pcie_size_to_value(int where, int size, unsigned int data, unsigned int value)
1753 +{
1754 +       unsigned int shift;
1755 +       unsigned int tdata = data;
1756 +
1757 +       switch (size) {
1758 +       case 1:
1759 +               shift = (where & 0x3) << 3;
1760 +               tdata &= ~(0xffU << shift);
1761 +               tdata |= ((value & 0xffU) << shift);
1762 +               break;
1763 +       case 2:
1764 +               shift = (where & 3) << 3;
1765 +               tdata &= ~(0xffffU << shift);
1766 +               tdata |= ((value & 0xffffU) << shift);
1767 +               break;
1768 +       case 4:
1769 +               tdata = value;
1770 +               break;
1771 +       }
1772 +       return tdata;
1773 +}
1774 +
1775 +/**
1776 + * \fn static static int ifx_pcie_write_config(struct pci_bus *bus, unsigned int devfn,
1777 + *                 int where, int size, unsigned int value)
1778 + * \brief Write a value to PCI configuration space
1779 + *
1780 + * \param[in] bus    Pointer to pci bus
1781 + * \param[in] devfn  PCI device function number
1782 + * \param[in] where  PCI register number
1783 + * \param[in] size   The register size to be written
1784 + * \param[in] value  The valule to be written
1785 + * \return PCIBIOS_BAD_REGISTER_NUMBER Invalid register number
1786 + * \return PCIBIOS_DEVICE_NOT_FOUND    PCI device not found
1787 + * \return PCIBIOS_SUCCESSFUL          OK
1788 + * \ingroup IFX_PCIE_OS
1789 + */
1790 +static int ifx_pcie_write_config(struct pci_bus *bus, unsigned int devfn, int where, int size, unsigned int value)
1791 +{
1792 +       int bus_number = bus->number;
1793 +       int ret = PCIBIOS_SUCCESSFUL;
1794 +       struct ifx_pci_controller *ctrl = bus->sysdata;
1795 +       int pcie_port = ctrl->port;
1796 +       unsigned int tvalue = value;
1797 +       unsigned int data;
1798 +
1799 +       /* Make sure the address is aligned to natural boundary */
1800 +       if (unlikely(((size - 1) & where))) {
1801 +               ret = PCIBIOS_BAD_REGISTER_NUMBER;
1802 +               goto out;
1803 +       }
1804 +       /*
1805 +        * If we are second controller, we have to cheat OS so that it assume
1806 +        * its bus number starts from 0 in host controller
1807 +        */
1808 +       bus_number = ifx_pcie_bus_nr_deduct(bus_number, pcie_port);
1809 +
1810 +       /*
1811 +        * We need to force the bus number to be zero on the root
1812 +        * bus. Linux numbers the 2nd root bus to start after all
1813 +        * busses on root 0.
1814 +        */
1815 +       if (bus->parent == NULL)
1816 +               bus_number = 0;
1817 +
1818 +       if (pcie_valid_config(pcie_port, bus_number, PCI_SLOT(devfn)) == 0) {
1819 +               ret = PCIBIOS_DEVICE_NOT_FOUND;
1820 +               goto out;
1821 +       }
1822 +
1823 +       IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG, "%s: %02x:%02x.%01x/%02x:%01d value=%08x\n", __func__,
1824 +               bus_number, PCI_SLOT(devfn), PCI_FUNC(devfn), where, size, value);
1825 +
1826 +       /* XXX, some PCIe device may need some delay */
1827 +       PCIE_IRQ_LOCK(ifx_pcie_lock);
1828 +
1829 +       /*
1830 +        * To configure the correct bus topology using native way, we have to cheat Os so that
1831 +        * it can configure the PCIe hardware correctly.
1832 +        */
1833 +       tvalue = ifx_pcie_bus_enum_hack(bus, devfn, where, value, pcie_port, 0);
1834 +
1835 +       if (bus_number == 0) { /* RC itself */
1836 +               unsigned int t;
1837 +
1838 +               t = (where & ~3);
1839 +               IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: wr local cfg, offset:%08x, fill:%08x\n", __func__, t, value);
1840 +               data = ifx_pcie_rc_cfg_rd(pcie_port, t);
1841 +               IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: rd local cfg, offset:%08x, data:%08x\n", __func__, t, data);
1842 +
1843 +               data = ifx_pcie_size_to_value(where, size, data, tvalue);
1844 +
1845 +               IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: wr local cfg, offset:%08x, value:%08x\n", __func__, t, data);
1846 +               ifx_pcie_rc_cfg_wr(pcie_port, t, data);
1847 +               IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: rd local cfg, offset:%08x, value:%08x\n",
1848 +                       __func__, t, ifx_pcie_rc_cfg_rd(pcie_port, t));
1849 +       } else {
1850 +               unsigned int addr = pcie_bus_addr(bus_number, devfn, where);
1851 +
1852 +               IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: wr cfg, offset:%08x, fill:%08x\n", __func__, addr, value);
1853 +               data = ifx_pcie_cfg_rd(pcie_port, addr);
1854 +               if (pcie_port == IFX_PCIE_PORT0) {
1855 +#ifdef CONFIG_IFX_PCIE_HW_SWAP
1856 +                       data = le32_to_cpu(data);
1857 +#endif /* CONFIG_IFX_PCIE_HW_SWAP */
1858 +               } else {
1859 +#ifdef CONFIG_IFX_PCIE1_HW_SWAP
1860 +                       data = le32_to_cpu(data);
1861 +#endif /* CONFIG_IFX_PCIE_HW_SWAP */
1862 +               }
1863 +               IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG,"%s: rd cfg, offset:%08x, data:%08x\n", __func__, addr, data);
1864 +
1865 +               data = ifx_pcie_size_to_value(where, size, data, tvalue);
1866 +               if (pcie_port == IFX_PCIE_PORT0) {
1867 +#ifdef CONFIG_IFX_PCIE_HW_SWAP
1868 +                       data = cpu_to_le32(data);
1869 +#endif /* CONFIG_IFX_PCIE_HW_SWAP */
1870 +               } else {
1871 +#ifdef CONFIG_IFX_PCIE1_HW_SWAP
1872 +                       data = cpu_to_le32(data);
1873 +#endif /* CONFIG_IFX_PCIE_HW_SWAP */
1874 +               }
1875 +               IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG, "%s: wr cfg, offset:%08x, value:%08x\n", __func__, addr, data);
1876 +               ifx_pcie_cfg_wr(pcie_port, addr, data);
1877 +               IFX_PCIE_PRINT(PCIE_MSG_WRITE_CFG, "%s: rd cfg, offset:%08x, value:%08x\n",
1878 +                       __func__, addr, ifx_pcie_cfg_rd(pcie_port, addr));
1879 +       }
1880 +       PCIE_IRQ_UNLOCK(ifx_pcie_lock);
1881 +out:
1882 +       return ret;
1883 +}
1884 +
1885 +static struct resource ifx_pcie_io_resource = {
1886 +       .name  = "PCIe0 I/O space",
1887 +       .start = PCIE_IO_PHY_BASE,
1888 +       .end = PCIE_IO_PHY_END,
1889 +       .flags = IORESOURCE_IO,
1890 +};
1891 +
1892 +static struct resource ifx_pcie_mem_resource = {
1893 +       .name = "PCIe0 Memory space",
1894 +       .start = PCIE_MEM_PHY_BASE,
1895 +       .end = PCIE_MEM_PHY_END,
1896 +       .flags = IORESOURCE_MEM,
1897 +};
1898 +
1899 +static struct pci_ops ifx_pcie_ops = {
1900 +       .read = ifx_pcie_read_config,
1901 +       .write = ifx_pcie_write_config,
1902 +};
1903 +
1904 +static struct ifx_pci_controller ifx_pcie_controller[IFX_PCIE_CORE_NR] = {
1905 +       {
1906 +               .pcic = {
1907 +                       .pci_ops = &ifx_pcie_ops,
1908 +                       .mem_resource = &ifx_pcie_mem_resource,
1909 +                       .io_resource = &ifx_pcie_io_resource,
1910 +               },
1911 +               .port = IFX_PCIE_PORT0,
1912 +       },
1913 +};
1914 +
1915 +static inline void pcie_core_int_clear_all(int pcie_port)
1916 +{
1917 +       unsigned int reg;
1918 +       reg = IFX_REG_R32(PCIE_IRNCR(pcie_port));
1919 +       reg &= PCIE_RC_CORE_COMBINED_INT;
1920 +       IFX_REG_W32(reg, PCIE_IRNCR(pcie_port));
1921 +}
1922 +
1923 +static irqreturn_t pcie_rc_core_isr(int irq, void *dev_id)
1924 +{
1925 +       struct ifx_pci_controller *ctrl = (struct ifx_pci_controller *)dev_id;
1926 +       int pcie_port = ctrl->port;
1927 +
1928 +       IFX_PCIE_PRINT(PCIE_MSG_ISR, "PCIe RC error intr %d\n", irq);
1929 +       pcie_core_int_clear_all(pcie_port);
1930 +       return IRQ_HANDLED;
1931 +}
1932 +
1933 +static int pcie_rc_core_int_init(int pcie_port)
1934 +{
1935 +       int ret;
1936 +
1937 +       /* Enable core interrupt */
1938 +       IFX_REG_SET_BIT(PCIE_RC_CORE_COMBINED_INT, PCIE_IRNEN(pcie_port));
1939 +
1940 +       /* Clear it first */
1941 +       IFX_REG_SET_BIT(PCIE_RC_CORE_COMBINED_INT, PCIE_IRNCR(pcie_port));
1942 +       ret = request_irq(pcie_irqs[pcie_port].ir_irq.irq, pcie_rc_core_isr, IRQF_DISABLED,
1943 +       pcie_irqs[pcie_port].ir_irq.name, &ifx_pcie_controller[pcie_port]);
1944 +       if (ret)
1945 +               printk(KERN_ERR "%s request irq %d failed\n", __func__, IFX_PCIE_IR);
1946 +
1947 +       return ret;
1948 +}
1949 +
1950 +int ifx_pcie_bios_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
1951 +{
1952 +       unsigned int irq_bit = 0;
1953 +       int irq = 0;
1954 +       struct ifx_pci_controller *ctrl = dev->bus->sysdata;
1955 +       int pcie_port = ctrl->port;
1956 +
1957 +       IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s port %d dev %s slot %d pin %d \n", __func__, pcie_port, pci_name(dev), slot, pin);
1958 +
1959 +       if ((pin == PCIE_LEGACY_DISABLE) || (pin > PCIE_LEGACY_INT_MAX)) {
1960 +               printk(KERN_WARNING "WARNING: dev %s: invalid interrupt pin %d\n", pci_name(dev), pin);
1961 +               return -1;
1962 +       }
1963 +       /* Pin index so minus one */
1964 +       irq_bit = pcie_irqs[pcie_port].legacy_irq[pin - 1].irq_bit;
1965 +       irq = pcie_irqs[pcie_port].legacy_irq[pin - 1].irq;
1966 +       IFX_REG_SET_BIT(irq_bit, PCIE_IRNEN(pcie_port));
1967 +       IFX_REG_SET_BIT(irq_bit, PCIE_IRNCR(pcie_port));
1968 +       IFX_PCIE_PRINT(PCIE_MSG_FIXUP, "%s dev %s irq %d assigned\n", __func__, pci_name(dev), irq);
1969 +       return irq;
1970 +}
1971 +
1972 +/**
1973 + * \fn int ifx_pcie_bios_plat_dev_init(struct pci_dev *dev)
1974 + * \brief Called to perform platform specific PCI setup
1975 + *
1976 + * \param[in] dev The Linux PCI device structure for the device to map
1977 + * \return OK
1978 + * \ingroup IFX_PCIE_OS
1979 + */
1980 +int ifx_pcie_bios_plat_dev_init(struct pci_dev *dev)
1981 +{
1982 +       u16 config;
1983 +       unsigned int dconfig;
1984 +       int pos;
1985 +       /* Enable reporting System errors and parity errors on all devices */
1986 +       /* Enable parity checking and error reporting */
1987 +       pci_read_config_word(dev, PCI_COMMAND, &config);
1988 +       config |= PCI_COMMAND_PARITY | PCI_COMMAND_SERR /*| PCI_COMMAND_INVALIDATE |
1989 +       PCI_COMMAND_FAST_BACK*/;
1990 +       pci_write_config_word(dev, PCI_COMMAND, config);
1991 +
1992 +       if (dev->subordinate) {
1993 +               /* Set latency timers on sub bridges */
1994 +               pci_write_config_byte(dev, PCI_SEC_LATENCY_TIMER, 0x40); /* XXX, */
1995 +               /* More bridge error detection */
1996 +               pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &config);
1997 +               config |= PCI_BRIDGE_CTL_PARITY | PCI_BRIDGE_CTL_SERR;
1998 +               pci_write_config_word(dev, PCI_BRIDGE_CONTROL, config);
1999 +       }
2000 +       /* Enable the PCIe normal error reporting */
2001 +       pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
2002 +       if (pos) {
2003 +               /* Disable system error generation in response to error messages */
2004 +               pci_read_config_word(dev, pos + PCI_EXP_RTCTL, &config);
2005 +               config &= ~(PCI_EXP_RTCTL_SECEE | PCI_EXP_RTCTL_SENFEE | PCI_EXP_RTCTL_SEFEE);
2006 +               pci_write_config_word(dev, pos + PCI_EXP_RTCTL, config);
2007 +
2008 +               /* Clear PCIE Capability's Device Status */
2009 +               pci_read_config_word(dev, pos + PCI_EXP_DEVSTA, &config);
2010 +               pci_write_config_word(dev, pos + PCI_EXP_DEVSTA, config);
2011 +
2012 +               /* Update Device Control */
2013 +               pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &config);
2014 +               /* Correctable Error Reporting */
2015 +               config |= PCI_EXP_DEVCTL_CERE;
2016 +               /* Non-Fatal Error Reporting */
2017 +               config |= PCI_EXP_DEVCTL_NFERE;
2018 +               /* Fatal Error Reporting */
2019 +               config |= PCI_EXP_DEVCTL_FERE;
2020 +               /* Unsupported Request */
2021 +               config |= PCI_EXP_DEVCTL_URRE;
2022 +               pci_write_config_word(dev, pos + PCI_EXP_DEVCTL, config);
2023 +       }
2024 +
2025 +       /* Find the Advanced Error Reporting capability */
2026 +       pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
2027 +       if (pos) {
2028 +               /* Clear Uncorrectable Error Status */
2029 +               pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS, &dconfig);
2030 +               pci_write_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS, dconfig);
2031 +               /* Enable reporting of all uncorrectable errors */
2032 +               /* Uncorrectable Error Mask - turned on bits disable errors */
2033 +               pci_write_config_dword(dev, pos + PCI_ERR_UNCOR_MASK, 0);
2034 +               /*
2035 +                * Leave severity at HW default. This only controls if
2036 +                * errors are reported as uncorrectable or
2037 +                * correctable, not if the error is reported.
2038 +                */
2039 +               /* PCI_ERR_UNCOR_SEVER - Uncorrectable Error Severity */
2040 +               /* Clear Correctable Error Status */
2041 +               pci_read_config_dword(dev, pos + PCI_ERR_COR_STATUS, &dconfig);
2042 +               pci_write_config_dword(dev, pos + PCI_ERR_COR_STATUS, dconfig);
2043 +               /* Enable reporting of all correctable errors */
2044 +               /* Correctable Error Mask - turned on bits disable errors */
2045 +               pci_write_config_dword(dev, pos + PCI_ERR_COR_MASK, 0);
2046 +               /* Advanced Error Capabilities */
2047 +               pci_read_config_dword(dev, pos + PCI_ERR_CAP, &dconfig);
2048 +               /* ECRC Generation Enable */
2049 +               if (dconfig & PCI_ERR_CAP_ECRC_GENC)
2050 +                       dconfig |= PCI_ERR_CAP_ECRC_GENE;
2051 +               /* ECRC Check Enable */
2052 +               if (dconfig & PCI_ERR_CAP_ECRC_CHKC)
2053 +                       dconfig |= PCI_ERR_CAP_ECRC_CHKE;
2054 +               pci_write_config_dword(dev, pos + PCI_ERR_CAP, dconfig);
2055 +
2056 +               /* PCI_ERR_HEADER_LOG - Header Log Register (16 bytes) */
2057 +               /* Enable Root Port's interrupt in response to error messages */
2058 +               pci_write_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND,
2059 +                       PCI_ERR_ROOT_CMD_COR_EN |
2060 +                       PCI_ERR_ROOT_CMD_NONFATAL_EN |
2061 +                       PCI_ERR_ROOT_CMD_FATAL_EN);
2062 +               /* Clear the Root status register */
2063 +               pci_read_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, &dconfig);
2064 +               pci_write_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, dconfig);
2065 +       }
2066 +       /* WAR, only 128 MRRS is supported, force all EPs to support this value */
2067 +       pcie_set_readrq(dev, 128);
2068 +       return 0;
2069 +}
2070 +
2071 +static void pcie_phy_rst(int pcie_port)
2072 +{
2073 +       pcie_phy_rst_assert(pcie_port);
2074 +       pcie_phy_rst_deassert(pcie_port);
2075 +       /* Make sure PHY PLL is stable */
2076 +       udelay(20);
2077 +}
2078 +
2079 +static int pcie_rc_initialize(int pcie_port)
2080 +{
2081 +       int i;
2082 +
2083 +       pcie_rcu_endian_setup(pcie_port);
2084 +
2085 +       pcie_ep_gpio_rst_init(pcie_port);
2086 +
2087 +       /*
2088 +        * XXX, PCIe elastic buffer bug will cause not to be detected. One more
2089 +        * reset PCIe PHY will solve this issue
2090 +        */
2091 +       for (i = 0; i < IFX_PCIE_PHY_LOOP_CNT; i++) {
2092 +               /* Disable PCIe PHY Analog part for sanity check */
2093 +               pcie_phy_pmu_disable(pcie_port);
2094 +               pcie_phy_rst(pcie_port);
2095 +               /* PCIe Core reset enabled, low active, sw programmed */
2096 +               pcie_core_rst_assert(pcie_port);
2097 +               /* Put PCIe EP in reset status */
2098 +               pcie_device_rst_assert(pcie_port);
2099 +               /* PCI PHY & Core reset disabled, high active, sw programmed */
2100 +               pcie_core_rst_deassert(pcie_port);
2101 +               /* Already in a quiet state, program PLL, enable PHY, check ready bit */
2102 +               pcie_phy_clock_mode_setup(pcie_port);
2103 +               /* Enable PCIe PHY and Clock */
2104 +               pcie_core_pmu_setup(pcie_port);
2105 +               /* Clear status registers */
2106 +               pcie_status_register_clear(pcie_port);
2107 +#ifdef CONFIG_PCI_MSI
2108 +               pcie_msi_init(pcie_port);
2109 +#endif /* CONFIG_PCI_MSI */
2110 +               pcie_rc_cfg_reg_setup(pcie_port);
2111 +
2112 +               /* Once link is up, break out */
2113 +               if (pcie_app_loigc_setup(pcie_port) == 0)
2114 +                       break;
2115 +       }
2116 +       if (i >= IFX_PCIE_PHY_LOOP_CNT) {
2117 +               printk(KERN_ERR "%s link up failed!!!!!\n", __func__);
2118 +               return -EIO;
2119 +       }
2120 +       /* NB, don't increase ACK/NACK timer timeout value, which will cause a lot of COR errors */
2121 +       pcie_replay_time_update(pcie_port);
2122 +       return 0;
2123 +}
2124 +
2125 +static int inline ifx_pcie_startup_port_nr(void)
2126 +{
2127 +       int pcie_port = IFX_PCIE_PORT0;
2128 +
2129 +       pcie_port = IFX_PCIE_PORT0;
2130 +       return pcie_port;
2131 +}
2132 +
2133 +/**
2134 + * \fn static int __init ifx_pcie_bios_init(void)
2135 + * \brief Initialize the IFX PCIe controllers
2136 + *
2137 + * \return -EIO    PCIe PHY link is not up
2138 + * \return -ENOMEM Configuration/IO space failed to map
2139 + * \return 0       OK
2140 + * \ingroup IFX_PCIE_OS
2141 + */
2142 +extern int (*ltqpci_plat_arch_init)(struct pci_dev *dev);
2143 +extern int (*ltqpci_map_irq)(const struct pci_dev *dev, u8 slot, u8 pin);
2144 +static int __devinit ltq_pcie_probe(struct platform_device *pdev)
2145 +{
2146 +       char ver_str[128] = {0};
2147 +       void __iomem *io_map_base;
2148 +       int pcie_port;
2149 +       int startup_port;
2150 +       ltqpci_map_irq = ifx_pcie_bios_map_irq;
2151 +       ltqpci_plat_arch_init = ifx_pcie_bios_plat_dev_init;
2152 +       /* Enable AHB Master/ Slave */
2153 +       pcie_ahb_pmu_setup();
2154 +
2155 +       startup_port = ifx_pcie_startup_port_nr();
2156 +
2157 +       ltq_gpio_request(&pdev->dev, IFX_PCIE_GPIO_RESET, 0, 1, "pcie-reset");
2158 +
2159 +       for (pcie_port = startup_port; pcie_port < IFX_PCIE_CORE_NR; pcie_port++){
2160 +               if (pcie_rc_initialize(pcie_port) == 0) {
2161 +                       /* Otherwise, warning will pop up */
2162 +                       io_map_base = ioremap(PCIE_IO_PHY_PORT_TO_BASE(pcie_port), PCIE_IO_SIZE);
2163 +                       if (io_map_base == NULL)
2164 +                               return -ENOMEM;
2165 +                       ifx_pcie_controller[pcie_port].pcic.io_map_base = (unsigned long)io_map_base;
2166 +                       register_pci_controller(&ifx_pcie_controller[pcie_port].pcic);
2167 +                       /* XXX, clear error status */
2168 +                       pcie_rc_core_int_init(pcie_port);
2169 +               }
2170 +       }
2171 +
2172 +       printk(KERN_INFO "%s", ver_str);
2173 +return 0;
2174 +}
2175 +
2176 +static struct platform_driver ltq_pcie_driver = {
2177 +       .probe = ltq_pcie_probe,
2178 +       .driver = {
2179 +               .name = "pcie-xway",
2180 +               .owner = THIS_MODULE,
2181 +       },
2182 +};
2183 +
2184 +int __init pciebios_init(void)
2185 +{
2186 +       return platform_driver_register(&ltq_pcie_driver);
2187 +}
2188 +
2189 +arch_initcall(pciebios_init);
2190 diff --git a/arch/mips/pci/pcie-lantiq.h b/arch/mips/pci/pcie-lantiq.h
2191 new file mode 100644
2192 index 0000000..d877c23
2193 --- /dev/null
2194 +++ b/arch/mips/pci/pcie-lantiq.h
2195 @@ -0,0 +1,1305 @@
2196 +/******************************************************************************
2197 +**
2198 +** FILE NAME    : ifxmips_pcie_reg.h
2199 +** PROJECT      : IFX UEIP for VRX200
2200 +** MODULES      : PCIe module
2201 +**
2202 +** DATE         : 02 Mar 2009
2203 +** AUTHOR       : Lei Chuanhua
2204 +** DESCRIPTION  : PCIe Root Complex Driver
2205 +** COPYRIGHT    :       Copyright (c) 2009
2206 +**                      Infineon Technologies AG
2207 +**                      Am Campeon 1-12, 85579 Neubiberg, Germany
2208 +**
2209 +**    This program is free software; you can redistribute it and/or modify
2210 +**    it under the terms of the GNU General Public License as published by
2211 +**    the Free Software Foundation; either version 2 of the License, or
2212 +**    (at your option) any later version.
2213 +** HISTORY
2214 +** $Version $Date        $Author         $Comment
2215 +** 0.0.1    17 Mar,2009  Lei Chuanhua    Initial version
2216 +*******************************************************************************/
2217 +#ifndef IFXMIPS_PCIE_REG_H
2218 +#define IFXMIPS_PCIE_REG_H
2219 +#include <linux/version.h>
2220 +#include <linux/types.h>
2221 +#include <linux/pci.h>
2222 +#include <linux/interrupt.h>
2223 +/*!
2224 + \file ifxmips_pcie_reg.h
2225 + \ingroup IFX_PCIE
2226 + \brief header file for PCIe module register definition
2227 +*/
2228 +/* PCIe Address Mapping Base */
2229 +#define PCIE_CFG_PHY_BASE        0x1D000000UL
2230 +#define PCIE_CFG_BASE           (KSEG1 + PCIE_CFG_PHY_BASE)
2231 +#define PCIE_CFG_SIZE           (8 * 1024 * 1024)
2232 +
2233 +#define PCIE_MEM_PHY_BASE        0x1C000000UL
2234 +#define PCIE_MEM_BASE           (KSEG1 + PCIE_MEM_PHY_BASE)
2235 +#define PCIE_MEM_SIZE           (16 * 1024 * 1024)
2236 +#define PCIE_MEM_PHY_END        (PCIE_MEM_PHY_BASE + PCIE_MEM_SIZE - 1)
2237 +
2238 +#define PCIE_IO_PHY_BASE         0x1D800000UL
2239 +#define PCIE_IO_BASE            (KSEG1 + PCIE_IO_PHY_BASE)
2240 +#define PCIE_IO_SIZE            (1 * 1024 * 1024)
2241 +#define PCIE_IO_PHY_END         (PCIE_IO_PHY_BASE + PCIE_IO_SIZE - 1)
2242 +
2243 +#define PCIE_RC_CFG_BASE        (KSEG1 + 0x1D900000)
2244 +#define PCIE_APP_LOGIC_REG      (KSEG1 + 0x1E100900)
2245 +#define PCIE_MSI_PHY_BASE        0x1F600000UL
2246 +
2247 +#define PCIE_PDI_PHY_BASE        0x1F106800UL
2248 +#define PCIE_PDI_BASE           (KSEG1 + PCIE_PDI_PHY_BASE)
2249 +#define PCIE_PDI_SIZE            0x400
2250 +
2251 +#define PCIE1_CFG_PHY_BASE        0x19000000UL
2252 +#define PCIE1_CFG_BASE           (KSEG1 + PCIE1_CFG_PHY_BASE)
2253 +#define PCIE1_CFG_SIZE           (8 * 1024 * 1024)
2254 +
2255 +#define PCIE1_MEM_PHY_BASE        0x18000000UL
2256 +#define PCIE1_MEM_BASE           (KSEG1 + PCIE1_MEM_PHY_BASE)
2257 +#define PCIE1_MEM_SIZE           (16 * 1024 * 1024)
2258 +#define PCIE1_MEM_PHY_END        (PCIE1_MEM_PHY_BASE + PCIE1_MEM_SIZE - 1)
2259 +
2260 +#define PCIE1_IO_PHY_BASE         0x19800000UL
2261 +#define PCIE1_IO_BASE            (KSEG1 + PCIE1_IO_PHY_BASE)
2262 +#define PCIE1_IO_SIZE            (1 * 1024 * 1024)
2263 +#define PCIE1_IO_PHY_END         (PCIE1_IO_PHY_BASE + PCIE1_IO_SIZE - 1)
2264 +
2265 +#define PCIE1_RC_CFG_BASE        (KSEG1 + 0x19900000)
2266 +#define PCIE1_APP_LOGIC_REG      (KSEG1 + 0x1E100700)
2267 +#define PCIE1_MSI_PHY_BASE        0x1F400000UL
2268 +
2269 +#define PCIE1_PDI_PHY_BASE        0x1F700400UL
2270 +#define PCIE1_PDI_BASE           (KSEG1 + PCIE1_PDI_PHY_BASE)
2271 +#define PCIE1_PDI_SIZE            0x400
2272 +
2273 +#define PCIE_CFG_PORT_TO_BASE(X)     ((X) > 0 ? (PCIE1_CFG_BASE) : (PCIE_CFG_BASE))
2274 +#define PCIE_MEM_PORT_TO_BASE(X)     ((X) > 0 ? (PCIE1_MEM_BASE) : (PCIE_MEM_BASE))
2275 +#define PCIE_IO_PORT_TO_BASE(X)      ((X) > 0 ? (PCIE1_IO_BASE) : (PCIE_IO_BASE))
2276 +#define PCIE_MEM_PHY_PORT_TO_BASE(X) ((X) > 0 ? (PCIE1_MEM_PHY_BASE) : (PCIE_MEM_PHY_BASE))
2277 +#define PCIE_MEM_PHY_PORT_TO_END(X)  ((X) > 0 ? (PCIE1_MEM_PHY_END) : (PCIE_MEM_PHY_END))
2278 +#define PCIE_IO_PHY_PORT_TO_BASE(X)  ((X) > 0 ? (PCIE1_IO_PHY_BASE) : (PCIE_IO_PHY_BASE))
2279 +#define PCIE_IO_PHY_PORT_TO_END(X)   ((X) > 0 ? (PCIE1_IO_PHY_END) : (PCIE_IO_PHY_END))
2280 +#define PCIE_APP_PORT_TO_BASE(X)     ((X) > 0 ? (PCIE1_APP_LOGIC_REG) : (PCIE_APP_LOGIC_REG))
2281 +#define PCIE_RC_PORT_TO_BASE(X)      ((X) > 0 ? (PCIE1_RC_CFG_BASE) : (PCIE_RC_CFG_BASE))
2282 +#define PCIE_PHY_PORT_TO_BASE(X)     ((X) > 0 ? (PCIE1_PDI_BASE) : (PCIE_PDI_BASE))
2283 +
2284 +/* PCIe Application Logic Register */
2285 +/* RC Core Control Register */
2286 +#define PCIE_RC_CCR(X)                      (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x10)
2287 +/* This should be enabled after initializing configuratin registers
2288 + * Also should check link status retraining bit
2289 + */
2290 +#define PCIE_RC_CCR_LTSSM_ENABLE             0x00000001    /* Enable LTSSM to continue link establishment */
2291 +
2292 +/* RC Core Debug Register */
2293 +#define PCIE_RC_DR(X)                       (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x14)
2294 +#define PCIE_RC_DR_DLL_UP                    0x00000001  /* Data Link Layer Up */
2295 +#define PCIE_RC_DR_CURRENT_POWER_STATE       0x0000000E  /* Current Power State */
2296 +#define PCIE_RC_DR_CURRENT_POWER_STATE_S     1
2297 +#define PCIE_RC_DR_CURRENT_LTSSM_STATE       0x000001F0  /* Current LTSSM State */
2298 +#define PCIE_RC_DR_CURRENT_LTSSM_STATE_S     4
2299 +
2300 +#define PCIE_RC_DR_PM_DEV_STATE              0x00000E00  /* Power Management D-State */
2301 +#define PCIE_RC_DR_PM_DEV_STATE_S            9
2302 +
2303 +#define PCIE_RC_DR_PM_ENABLED                0x00001000  /* Power Management State from PMU */
2304 +#define PCIE_RC_DR_PME_EVENT_ENABLED         0x00002000  /* Power Management Event Enable State */
2305 +#define PCIE_RC_DR_AUX_POWER_ENABLED         0x00004000  /* Auxiliary Power Enable */
2306 +
2307 +/* Current Power State Definition */
2308 +enum {
2309 +    PCIE_RC_DR_D0 = 0,
2310 +    PCIE_RC_DR_D1,   /* Not supported */
2311 +    PCIE_RC_DR_D2,   /* Not supported */
2312 +    PCIE_RC_DR_D3,
2313 +    PCIE_RC_DR_UN,
2314 +};
2315 +
2316 +/* PHY Link Status Register */
2317 +#define PCIE_PHY_SR(X)                      (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x18)
2318 +#define PCIE_PHY_SR_PHY_LINK_UP              0x00000001   /* PHY Link Up/Down Indicator */
2319 +
2320 +/* Electromechanical Control Register */
2321 +#define PCIE_EM_CR(X)                       (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x1C)
2322 +#define PCIE_EM_CR_CARD_IS_PRESENT           0x00000001  /* Card Presence Detect State */
2323 +#define PCIE_EM_CR_MRL_OPEN                  0x00000002  /* MRL Sensor State */
2324 +#define PCIE_EM_CR_POWER_FAULT_SET           0x00000004  /* Power Fault Detected */
2325 +#define PCIE_EM_CR_MRL_SENSOR_SET            0x00000008  /* MRL Sensor Changed */
2326 +#define PCIE_EM_CR_PRESENT_DETECT_SET        0x00000010  /* Card Presense Detect Changed */
2327 +#define PCIE_EM_CR_CMD_CPL_INT_SET           0x00000020  /* Command Complete Interrupt */
2328 +#define PCIE_EM_CR_SYS_INTERLOCK_SET         0x00000040  /* System Electromechanical IterLock Engaged */
2329 +#define PCIE_EM_CR_ATTENTION_BUTTON_SET      0x00000080  /* Attention Button Pressed */
2330 +
2331 +/* Interrupt Status Register */
2332 +#define PCIE_IR_SR(X)                       (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x20)
2333 +#define PCIE_IR_SR_PME_CAUSE_MSI             0x00000002  /* MSI caused by PME */
2334 +#define PCIE_IR_SR_HP_PME_WAKE_GEN           0x00000004  /* Hotplug PME Wake Generation */
2335 +#define PCIE_IR_SR_HP_MSI                    0x00000008  /* Hotplug MSI */
2336 +#define PCIE_IR_SR_AHB_LU_ERR                0x00000030  /* AHB Bridge Lookup Error Signals */
2337 +#define PCIE_IR_SR_AHB_LU_ERR_S              4
2338 +#define PCIE_IR_SR_INT_MSG_NUM               0x00003E00  /* Interrupt Message Number */
2339 +#define PCIE_IR_SR_INT_MSG_NUM_S             9
2340 +#define PCIE_IR_SR_AER_INT_MSG_NUM           0xF8000000  /* Advanced Error Interrupt Message Number */
2341 +#define PCIE_IR_SR_AER_INT_MSG_NUM_S         27
2342 +
2343 +/* Message Control Register */
2344 +#define PCIE_MSG_CR(X)                      (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x30)
2345 +#define PCIE_MSG_CR_GEN_PME_TURN_OFF_MSG     0x00000001  /* Generate PME Turn Off Message */
2346 +#define PCIE_MSG_CR_GEN_UNLOCK_MSG           0x00000002  /* Generate Unlock Message */
2347 +
2348 +#define PCIE_VDM_DR(X)                      (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x34)
2349 +
2350 +/* Vendor-Defined Message Requester ID Register */
2351 +#define PCIE_VDM_RID(X)                     (PCIE_APP_PORT_TO_BASE (X) + 0x38)
2352 +#define PCIE_VDM_RID_VENROR_MSG_REQ_ID       0x0000FFFF
2353 +#define PCIE_VDM_RID_VDMRID_S                0
2354 +
2355 +/* ASPM Control Register */
2356 +#define PCIE_ASPM_CR(X)                     (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x40)
2357 +#define PCIE_ASPM_CR_HOT_RST                 0x00000001  /* Hot Reset Request to the downstream device */
2358 +#define PCIE_ASPM_CR_REQ_EXIT_L1             0x00000002  /* Request to Exit L1 */
2359 +#define PCIE_ASPM_CR_REQ_ENTER_L1            0x00000004  /* Request to Enter L1 */
2360 +
2361 +/* Vendor Message DW0 Register */
2362 +#define PCIE_VM_MSG_DW0(X)                  (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x50)
2363 +#define PCIE_VM_MSG_DW0_TYPE                 0x0000001F  /* Message type */
2364 +#define PCIE_VM_MSG_DW0_TYPE_S               0
2365 +#define PCIE_VM_MSG_DW0_FORMAT               0x00000060  /* Format */
2366 +#define PCIE_VM_MSG_DW0_FORMAT_S             5
2367 +#define PCIE_VM_MSG_DW0_TC                   0x00007000  /* Traffic Class */
2368 +#define PCIE_VM_MSG_DW0_TC_S                 12
2369 +#define PCIE_VM_MSG_DW0_ATTR                 0x000C0000  /* Atrributes */
2370 +#define PCIE_VM_MSG_DW0_ATTR_S               18
2371 +#define PCIE_VM_MSG_DW0_EP_TLP               0x00100000  /* Poisoned TLP */
2372 +#define PCIE_VM_MSG_DW0_TD                   0x00200000  /* TLP Digest */
2373 +#define PCIE_VM_MSG_DW0_LEN                  0xFFC00000  /* Length */
2374 +#define PCIE_VM_MSG_DW0_LEN_S                22
2375 +
2376 +/* Format Definition */
2377 +enum {
2378 +    PCIE_VM_MSG_FORMAT_00 = 0,  /* 3DW Hdr, no data*/
2379 +    PCIE_VM_MSG_FORMAT_01,      /* 4DW Hdr, no data */
2380 +    PCIE_VM_MSG_FORMAT_10,      /* 3DW Hdr, with data */
2381 +    PCIE_VM_MSG_FORMAT_11,      /* 4DW Hdr, with data */
2382 +};
2383 +
2384 +/* Traffic Class Definition */
2385 +enum {
2386 +    PCIE_VM_MSG_TC0 = 0,
2387 +    PCIE_VM_MSG_TC1,
2388 +    PCIE_VM_MSG_TC2,
2389 +    PCIE_VM_MSG_TC3,
2390 +    PCIE_VM_MSG_TC4,
2391 +    PCIE_VM_MSG_TC5,
2392 +    PCIE_VM_MSG_TC6,
2393 +    PCIE_VM_MSG_TC7,
2394 +};
2395 +
2396 +/* Attributes Definition */
2397 +enum {
2398 +    PCIE_VM_MSG_ATTR_00 = 0,   /* RO and No Snoop cleared */
2399 +    PCIE_VM_MSG_ATTR_01,       /* RO cleared , No Snoop set */
2400 +    PCIE_VM_MSG_ATTR_10,       /* RO set, No Snoop cleared*/
2401 +    PCIE_VM_MSG_ATTR_11,       /* RO and No Snoop set */
2402 +};
2403 +
2404 +/* Payload Size Definition */
2405 +#define PCIE_VM_MSG_LEN_MIN  0
2406 +#define PCIE_VM_MSG_LEN_MAX  1024
2407 +
2408 +/* Vendor Message DW1 Register */
2409 +#define PCIE_VM_MSG_DW1(X)                 (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x54)
2410 +#define PCIE_VM_MSG_DW1_FUNC_NUM            0x00000070  /* Function Number */
2411 +#define PCIE_VM_MSG_DW1_FUNC_NUM_S          8
2412 +#define PCIE_VM_MSG_DW1_CODE                0x00FF0000  /* Message Code */
2413 +#define PCIE_VM_MSG_DW1_CODE_S              16
2414 +#define PCIE_VM_MSG_DW1_TAG                 0xFF000000  /* Tag */
2415 +#define PCIE_VM_MSG_DW1_TAG_S               24
2416 +
2417 +#define PCIE_VM_MSG_DW2(X)                  (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x58)
2418 +#define PCIE_VM_MSG_DW3(X)                  (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x5C)
2419 +
2420 +/* Vendor Message Request Register */
2421 +#define PCIE_VM_MSG_REQR(X)                 (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x60)
2422 +#define PCIE_VM_MSG_REQR_REQ                 0x00000001  /* Vendor Message Request */
2423 +
2424 +
2425 +/* AHB Slave Side Band Control Register */
2426 +#define PCIE_AHB_SSB(X)                     (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x70)
2427 +#define PCIE_AHB_SSB_REQ_BCM                0x00000001 /* Slave Reques BCM filed */
2428 +#define PCIE_AHB_SSB_REQ_EP                 0x00000002 /* Slave Reques EP filed */
2429 +#define PCIE_AHB_SSB_REQ_TD                 0x00000004 /* Slave Reques TD filed */
2430 +#define PCIE_AHB_SSB_REQ_ATTR               0x00000018 /* Slave Reques Attribute number */
2431 +#define PCIE_AHB_SSB_REQ_ATTR_S             3
2432 +#define PCIE_AHB_SSB_REQ_TC                 0x000000E0 /* Slave Request TC Field */
2433 +#define PCIE_AHB_SSB_REQ_TC_S               5
2434 +
2435 +/* AHB Master SideBand Ctrl Register */
2436 +#define PCIE_AHB_MSB(X)                     (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x74)
2437 +#define PCIE_AHB_MSB_RESP_ATTR               0x00000003 /* Master Response Attribute number */
2438 +#define PCIE_AHB_MSB_RESP_ATTR_S             0
2439 +#define PCIE_AHB_MSB_RESP_BAD_EOT            0x00000004 /* Master Response Badeot filed */
2440 +#define PCIE_AHB_MSB_RESP_BCM                0x00000008 /* Master Response BCM filed */
2441 +#define PCIE_AHB_MSB_RESP_EP                 0x00000010 /* Master Response EP filed */
2442 +#define PCIE_AHB_MSB_RESP_TD                 0x00000020 /* Master Response TD filed */
2443 +#define PCIE_AHB_MSB_RESP_FUN_NUM            0x000003C0 /* Master Response Function number */
2444 +#define PCIE_AHB_MSB_RESP_FUN_NUM_S          6
2445 +
2446 +/* AHB Control Register, fixed bus enumeration exception */
2447 +#define PCIE_AHB_CTRL(X)                     (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0x78)
2448 +#define PCIE_AHB_CTRL_BUS_ERROR_SUPPRESS     0x00000001
2449 +
2450 +/* Interrupt Enalbe Register */
2451 +#define PCIE_IRNEN(X)                        (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0xF4)
2452 +#define PCIE_IRNCR(X)                        (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0xF8)
2453 +#define PCIE_IRNICR(X)                       (volatile u32*)(PCIE_APP_PORT_TO_BASE(X) + 0xFC)
2454 +
2455 +/* PCIe interrupt enable/control/capture register definition */
2456 +#define PCIE_IRN_AER_REPORT                 0x00000001  /* AER Interrupt */
2457 +#define PCIE_IRN_AER_MSIX                   0x00000002  /* Advanced Error MSI-X Interrupt */
2458 +#define PCIE_IRN_PME                        0x00000004  /* PME Interrupt */
2459 +#define PCIE_IRN_HOTPLUG                    0x00000008  /* Hotplug Interrupt */
2460 +#define PCIE_IRN_RX_VDM_MSG                 0x00000010  /* Vendor-Defined Message Interrupt */
2461 +#define PCIE_IRN_RX_CORRECTABLE_ERR_MSG     0x00000020  /* Correctable Error Message Interrupt */
2462 +#define PCIE_IRN_RX_NON_FATAL_ERR_MSG       0x00000040  /* Non-fatal Error Message */
2463 +#define PCIE_IRN_RX_FATAL_ERR_MSG           0x00000080  /* Fatal Error Message */
2464 +#define PCIE_IRN_RX_PME_MSG                 0x00000100  /* PME Message Interrupt */
2465 +#define PCIE_IRN_RX_PME_TURNOFF_ACK         0x00000200  /* PME Turnoff Ack Message Interrupt */
2466 +#define PCIE_IRN_AHB_BR_FATAL_ERR           0x00000400  /* AHB Fatal Error Interrupt */
2467 +#define PCIE_IRN_LINK_AUTO_BW_STATUS        0x00000800  /* Link Auto Bandwidth Status Interrupt */
2468 +#define PCIE_IRN_BW_MGT                     0x00001000  /* Bandwidth Managment Interrupt */
2469 +#define PCIE_IRN_INTA                       0x00002000  /* INTA */
2470 +#define PCIE_IRN_INTB                       0x00004000  /* INTB */
2471 +#define PCIE_IRN_INTC                       0x00008000  /* INTC */
2472 +#define PCIE_IRN_INTD                       0x00010000  /* INTD */
2473 +#define PCIE_IRN_WAKEUP                     0x00020000  /* Wake up Interrupt */
2474 +
2475 +#define PCIE_RC_CORE_COMBINED_INT    (PCIE_IRN_AER_REPORT |  PCIE_IRN_AER_MSIX | PCIE_IRN_PME | \
2476 +                                      PCIE_IRN_HOTPLUG | PCIE_IRN_RX_VDM_MSG | PCIE_IRN_RX_CORRECTABLE_ERR_MSG |\
2477 +                                      PCIE_IRN_RX_NON_FATAL_ERR_MSG | PCIE_IRN_RX_FATAL_ERR_MSG | \
2478 +                                      PCIE_IRN_RX_PME_MSG | PCIE_IRN_RX_PME_TURNOFF_ACK | PCIE_IRN_AHB_BR_FATAL_ERR | \
2479 +                                      PCIE_IRN_LINK_AUTO_BW_STATUS | PCIE_IRN_BW_MGT)
2480 +/* PCIe RC Configuration Register */
2481 +#define PCIE_VDID(X)                (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x00)
2482 +
2483 +/* Bit definition from pci_reg.h */
2484 +#define PCIE_PCICMDSTS(X)           (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x04)
2485 +#define PCIE_CCRID(X)               (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x08)
2486 +#define PCIE_CLSLTHTBR(X)           (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x0C) /* EP only */
2487 +/* BAR0, BAR1,Only necessary if the bridges implements a device-specific register set or memory buffer */
2488 +#define PCIE_BAR0(X)                (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x10) /* Not used*/
2489 +#define PCIE_BAR1(X)                (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x14) /* Not used */
2490 +
2491 +#define PCIE_BNR(X)                 (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x18) /* Mandatory */
2492 +/* Bus Number Register bits */
2493 +#define PCIE_BNR_PRIMARY_BUS_NUM             0x000000FF
2494 +#define PCIE_BNR_PRIMARY_BUS_NUM_S           0
2495 +#define PCIE_PNR_SECONDARY_BUS_NUM           0x0000FF00
2496 +#define PCIE_PNR_SECONDARY_BUS_NUM_S         8
2497 +#define PCIE_PNR_SUB_BUS_NUM                 0x00FF0000
2498 +#define PCIE_PNR_SUB_BUS_NUM_S               16
2499 +
2500 +/* IO Base/Limit Register bits */
2501 +#define PCIE_IOBLSECS(X)                       (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x1C)  /* RC only */
2502 +#define PCIE_IOBLSECS_32BIT_IO_ADDR             0x00000001
2503 +#define PCIE_IOBLSECS_IO_BASE_ADDR              0x000000F0
2504 +#define PCIE_IOBLSECS_IO_BASE_ADDR_S            4
2505 +#define PCIE_IOBLSECS_32BIT_IOLIMT              0x00000100
2506 +#define PCIE_IOBLSECS_IO_LIMIT_ADDR             0x0000F000
2507 +#define PCIE_IOBLSECS_IO_LIMIT_ADDR_S           12
2508 +
2509 +/* Non-prefetchable Memory Base/Limit Register bit */
2510 +#define PCIE_MBML(X)                           (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x20)  /* RC only */
2511 +#define PCIE_MBML_MEM_BASE_ADDR                 0x0000FFF0
2512 +#define PCIE_MBML_MEM_BASE_ADDR_S               4
2513 +#define PCIE_MBML_MEM_LIMIT_ADDR                0xFFF00000
2514 +#define PCIE_MBML_MEM_LIMIT_ADDR_S              20
2515 +
2516 +/* Prefetchable Memory Base/Limit Register bit */
2517 +#define PCIE_PMBL(X)                           (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x24)  /* RC only */
2518 +#define PCIE_PMBL_64BIT_ADDR                    0x00000001
2519 +#define PCIE_PMBL_UPPER_12BIT                   0x0000FFF0
2520 +#define PCIE_PMBL_UPPER_12BIT_S                 4
2521 +#define PCIE_PMBL_E64MA                         0x00010000
2522 +#define PCIE_PMBL_END_ADDR                      0xFFF00000
2523 +#define PCIE_PMBL_END_ADDR_S                    20
2524 +#define PCIE_PMBU32(X)                          (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x28)  /* RC only */
2525 +#define PCIE_PMLU32(X)                          (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x2C)  /* RC only */
2526 +
2527 +/* I/O Base/Limit Upper 16 bits register */
2528 +#define PCIE_IO_BANDL(X)                        (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x30)  /* RC only */
2529 +#define PCIE_IO_BANDL_UPPER_16BIT_IO_BASE        0x0000FFFF
2530 +#define PCIE_IO_BANDL_UPPER_16BIT_IO_BASE_S      0
2531 +#define PCIE_IO_BANDL_UPPER_16BIT_IO_LIMIT       0xFFFF0000
2532 +#define PCIE_IO_BANDL_UPPER_16BIT_IO_LIMIT_S     16
2533 +
2534 +#define PCIE_CPR(X)                            (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x34)
2535 +#define PCIE_EBBAR(X)                          (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x38)
2536 +
2537 +/* Interrupt and Secondary Bridge Control Register */
2538 +#define PCIE_INTRBCTRL(X)                      (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x3C)
2539 +
2540 +#define PCIE_INTRBCTRL_INT_LINE                 0x000000FF
2541 +#define PCIE_INTRBCTRL_INT_LINE_S               0
2542 +#define PCIE_INTRBCTRL_INT_PIN                  0x0000FF00
2543 +#define PCIE_INTRBCTRL_INT_PIN_S                8
2544 +#define PCIE_INTRBCTRL_PARITY_ERR_RESP_ENABLE   0x00010000    /* #PERR */
2545 +#define PCIE_INTRBCTRL_SERR_ENABLE              0x00020000    /* #SERR */
2546 +#define PCIE_INTRBCTRL_ISA_ENABLE               0x00040000    /* ISA enable, IO 64KB only */
2547 +#define PCIE_INTRBCTRL_VGA_ENABLE               0x00080000    /* VGA enable */
2548 +#define PCIE_INTRBCTRL_VGA_16BIT_DECODE         0x00100000    /* VGA 16bit decode */
2549 +#define PCIE_INTRBCTRL_RST_SECONDARY_BUS        0x00400000    /* Secondary bus rest, hot rest, 1ms */
2550 +/* Others are read only */
2551 +enum {
2552 +    PCIE_INTRBCTRL_INT_NON = 0,
2553 +    PCIE_INTRBCTRL_INTA,
2554 +    PCIE_INTRBCTRL_INTB,
2555 +    PCIE_INTRBCTRL_INTC,
2556 +    PCIE_INTRBCTRL_INTD,
2557 +};
2558 +
2559 +#define PCIE_PM_CAPR(X)                  (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x40)
2560 +
2561 +/* Power Management Control and Status Register */
2562 +#define PCIE_PM_CSR(X)                   (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x44)
2563 +
2564 +#define PCIE_PM_CSR_POWER_STATE           0x00000003   /* Power State */
2565 +#define PCIE_PM_CSR_POWER_STATE_S         0
2566 +#define PCIE_PM_CSR_SW_RST                0x00000008   /* Soft Reset Enabled */
2567 +#define PCIE_PM_CSR_PME_ENABLE            0x00000100   /* PME Enable */
2568 +#define PCIE_PM_CSR_PME_STATUS            0x00008000   /* PME status */
2569 +
2570 +/* MSI Capability Register for EP */
2571 +#define PCIE_MCAPR(X)                    (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x50)
2572 +
2573 +#define PCIE_MCAPR_MSI_CAP_ID             0x000000FF  /* MSI Capability ID */
2574 +#define PCIE_MCAPR_MSI_CAP_ID_S           0
2575 +#define PCIE_MCAPR_MSI_NEXT_CAP_PTR       0x0000FF00  /* Next Capability Pointer */
2576 +#define PCIE_MCAPR_MSI_NEXT_CAP_PTR_S     8
2577 +#define PCIE_MCAPR_MSI_ENABLE             0x00010000  /* MSI Enable */
2578 +#define PCIE_MCAPR_MULTI_MSG_CAP          0x000E0000  /* Multiple Message Capable */
2579 +#define PCIE_MCAPR_MULTI_MSG_CAP_S        17
2580 +#define PCIE_MCAPR_MULTI_MSG_ENABLE       0x00700000  /* Multiple Message Enable */
2581 +#define PCIE_MCAPR_MULTI_MSG_ENABLE_S     20
2582 +#define PCIE_MCAPR_ADDR64_CAP             0X00800000  /* 64-bit Address Capable */
2583 +
2584 +/* MSI Message Address Register */
2585 +#define PCIE_MA(X)                       (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x54)
2586 +
2587 +#define PCIE_MA_ADDR_MASK                 0xFFFFFFFC  /* Message Address */
2588 +
2589 +/* MSI Message Upper Address Register */
2590 +#define PCIE_MUA(X)                      (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x58)
2591 +
2592 +/* MSI Message Data Register */
2593 +#define PCIE_MD(X)                       (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x5C)
2594 +
2595 +#define PCIE_MD_DATA                      0x0000FFFF  /* Message Data */
2596 +#define PCIE_MD_DATA_S                    0
2597 +
2598 +/* PCI Express Capability Register */
2599 +#define PCIE_XCAP(X)                     (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x70)
2600 +
2601 +#define PCIE_XCAP_ID                      0x000000FF  /* PCI Express Capability ID */
2602 +#define PCIE_XCAP_ID_S                    0
2603 +#define PCIE_XCAP_NEXT_CAP                0x0000FF00  /* Next Capability Pointer */
2604 +#define PCIE_XCAP_NEXT_CAP_S              8
2605 +#define PCIE_XCAP_VER                     0x000F0000  /* PCI Express Capability Version */
2606 +#define PCIE_XCAP_VER_S                   16
2607 +#define PCIE_XCAP_DEV_PORT_TYPE           0x00F00000  /* Device Port Type */
2608 +#define PCIE_XCAP_DEV_PORT_TYPE_S         20
2609 +#define PCIE_XCAP_SLOT_IMPLEMENTED        0x01000000  /* Slot Implemented */
2610 +#define PCIE_XCAP_MSG_INT_NUM             0x3E000000  /* Interrupt Message Number */
2611 +#define PCIE_XCAP_MSG_INT_NUM_S           25
2612 +
2613 +/* Device Capability Register */
2614 +#define PCIE_DCAP(X)                     (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x74)
2615 +
2616 +#define PCIE_DCAP_MAX_PAYLOAD_SIZE        0x00000007   /* Max Payload size */
2617 +#define PCIE_DCAP_MAX_PAYLOAD_SIZE_S      0
2618 +#define PCIE_DCAP_PHANTOM_FUNC            0x00000018   /* Phanton Function, not supported */
2619 +#define PCIE_DCAP_PHANTOM_FUNC_S          3
2620 +#define PCIE_DCAP_EXT_TAG                 0x00000020   /* Extended Tag Field */
2621 +#define PCIE_DCAP_EP_L0S_LATENCY          0x000001C0   /* EP L0s latency only */
2622 +#define PCIE_DCAP_EP_L0S_LATENCY_S        6
2623 +#define PCIE_DCAP_EP_L1_LATENCY           0x00000E00   /* EP L1 latency only */
2624 +#define PCIE_DCAP_EP_L1_LATENCY_S         9
2625 +#define PCIE_DCAP_ROLE_BASE_ERR_REPORT    0x00008000   /* Role Based ERR */
2626 +
2627 +/* Maximum payload size supported */
2628 +enum {
2629 +    PCIE_MAX_PAYLOAD_128 = 0,
2630 +    PCIE_MAX_PAYLOAD_256,
2631 +    PCIE_MAX_PAYLOAD_512,
2632 +    PCIE_MAX_PAYLOAD_1024,
2633 +    PCIE_MAX_PAYLOAD_2048,
2634 +    PCIE_MAX_PAYLOAD_4096,
2635 +};
2636 +
2637 +/* Device Control and Status Register */
2638 +#define PCIE_DCTLSTS(X)                       (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x78)
2639 +
2640 +#define PCIE_DCTLSTS_CORRECTABLE_ERR_EN        0x00000001   /* COR-ERR */
2641 +#define PCIE_DCTLSTS_NONFATAL_ERR_EN           0x00000002   /* Non-fatal ERR */
2642 +#define PCIE_DCTLSTS_FATAL_ERR_EN              0x00000004   /* Fatal ERR */
2643 +#define PCIE_DCTLSYS_UR_REQ_EN                 0x00000008   /* UR ERR */
2644 +#define PCIE_DCTLSTS_RELAXED_ORDERING_EN       0x00000010   /* Enable relaxing ordering */
2645 +#define PCIE_DCTLSTS_MAX_PAYLOAD_SIZE          0x000000E0   /* Max payload mask */
2646 +#define PCIE_DCTLSTS_MAX_PAYLOAD_SIZE_S        5
2647 +#define PCIE_DCTLSTS_EXT_TAG_EN                0x00000100   /* Extended tag field */
2648 +#define PCIE_DCTLSTS_PHANTOM_FUNC_EN           0x00000200   /* Phantom Function Enable */
2649 +#define PCIE_DCTLSTS_AUX_PM_EN                 0x00000400   /* AUX Power PM Enable */
2650 +#define PCIE_DCTLSTS_NO_SNOOP_EN               0x00000800   /* Enable no snoop, except root port*/
2651 +#define PCIE_DCTLSTS_MAX_READ_SIZE             0x00007000   /* Max Read Request size*/
2652 +#define PCIE_DCTLSTS_MAX_READ_SIZE_S           12
2653 +#define PCIE_DCTLSTS_CORRECTABLE_ERR           0x00010000   /* COR-ERR Detected */
2654 +#define PCIE_DCTLSTS_NONFATAL_ERR              0x00020000   /* Non-Fatal ERR Detected */
2655 +#define PCIE_DCTLSTS_FATAL_ER                  0x00040000   /* Fatal ERR Detected */
2656 +#define PCIE_DCTLSTS_UNSUPPORTED_REQ           0x00080000   /* UR Detected */
2657 +#define PCIE_DCTLSTS_AUX_POWER                 0x00100000   /* Aux Power Detected */
2658 +#define PCIE_DCTLSTS_TRANSACT_PENDING          0x00200000   /* Transaction pending */
2659 +
2660 +#define PCIE_DCTLSTS_ERR_EN      (PCIE_DCTLSTS_CORRECTABLE_ERR_EN | \
2661 +                                  PCIE_DCTLSTS_NONFATAL_ERR_EN | PCIE_DCTLSTS_FATAL_ERR_EN | \
2662 +                                  PCIE_DCTLSYS_UR_REQ_EN)
2663 +
2664 +/* Link Capability Register */
2665 +#define PCIE_LCAP(X)                          (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x7C)
2666 +#define PCIE_LCAP_MAX_LINK_SPEED               0x0000000F  /* Max link speed, 0x1 by default */
2667 +#define PCIE_LCAP_MAX_LINK_SPEED_S             0
2668 +#define PCIE_LCAP_MAX_LENGTH_WIDTH             0x000003F0  /* Maxium Length Width */
2669 +#define PCIE_LCAP_MAX_LENGTH_WIDTH_S           4
2670 +#define PCIE_LCAP_ASPM_LEVEL                   0x00000C00  /* Active State Link PM Support */
2671 +#define PCIE_LCAP_ASPM_LEVEL_S                 10
2672 +#define PCIE_LCAP_L0S_EIXT_LATENCY             0x00007000  /* L0s Exit Latency */
2673 +#define PCIE_LCAP_L0S_EIXT_LATENCY_S           12
2674 +#define PCIE_LCAP_L1_EXIT_LATENCY              0x00038000  /* L1 Exit Latency */
2675 +#define PCIE_LCAP_L1_EXIT_LATENCY_S            15
2676 +#define PCIE_LCAP_CLK_PM                       0x00040000  /* Clock Power Management */
2677 +#define PCIE_LCAP_SDER                         0x00080000  /* Surprise Down Error Reporting */
2678 +#define PCIE_LCAP_DLL_ACTIVE_REPROT            0x00100000  /* Data Link Layer Active Reporting Capable */
2679 +#define PCIE_LCAP_PORT_NUM                     0xFF0000000  /* Port number */
2680 +#define PCIE_LCAP_PORT_NUM_S                   24
2681 +
2682 +/* Maximum Length width definition */
2683 +#define PCIE_MAX_LENGTH_WIDTH_RES  0x00
2684 +#define PCIE_MAX_LENGTH_WIDTH_X1   0x01  /* Default */
2685 +#define PCIE_MAX_LENGTH_WIDTH_X2   0x02
2686 +#define PCIE_MAX_LENGTH_WIDTH_X4   0x04
2687 +#define PCIE_MAX_LENGTH_WIDTH_X8   0x08
2688 +#define PCIE_MAX_LENGTH_WIDTH_X12  0x0C
2689 +#define PCIE_MAX_LENGTH_WIDTH_X16  0x10
2690 +#define PCIE_MAX_LENGTH_WIDTH_X32  0x20
2691 +
2692 +/* Active State Link PM definition */
2693 +enum {
2694 +    PCIE_ASPM_RES0                = 0,
2695 +    PCIE_ASPM_L0S_ENTRY_SUPPORT,        /* L0s */
2696 +    PCIE_ASPM_RES1,
2697 +    PCIE_ASPM_L0S_L1_ENTRY_SUPPORT,     /* L0s and L1, default */
2698 +};
2699 +
2700 +/* L0s Exit Latency definition */
2701 +enum {
2702 +    PCIE_L0S_EIXT_LATENCY_L64NS    = 0, /* < 64 ns */
2703 +    PCIE_L0S_EIXT_LATENCY_B64A128,      /* > 64 ns < 128 ns */
2704 +    PCIE_L0S_EIXT_LATENCY_B128A256,     /* > 128 ns < 256 ns */
2705 +    PCIE_L0S_EIXT_LATENCY_B256A512,     /* > 256 ns < 512 ns */
2706 +    PCIE_L0S_EIXT_LATENCY_B512TO1U,     /* > 512 ns < 1 us */
2707 +    PCIE_L0S_EIXT_LATENCY_B1A2U,        /* > 1 us < 2 us */
2708 +    PCIE_L0S_EIXT_LATENCY_B2A4U,        /* > 2 us < 4 us */
2709 +    PCIE_L0S_EIXT_LATENCY_M4US,         /* > 4 us  */
2710 +};
2711 +
2712 +/* L1 Exit Latency definition */
2713 +enum {
2714 +    PCIE_L1_EXIT_LATENCY_L1US  = 0,  /* < 1 us */
2715 +    PCIE_L1_EXIT_LATENCY_B1A2,       /* > 1 us < 2 us */
2716 +    PCIE_L1_EXIT_LATENCY_B2A4,       /* > 2 us < 4 us */
2717 +    PCIE_L1_EXIT_LATENCY_B4A8,       /* > 4 us < 8 us */
2718 +    PCIE_L1_EXIT_LATENCY_B8A16,      /* > 8 us < 16 us */
2719 +    PCIE_L1_EXIT_LATENCY_B16A32,     /* > 16 us < 32 us */
2720 +    PCIE_L1_EXIT_LATENCY_B32A64,     /* > 32 us < 64 us */
2721 +    PCIE_L1_EXIT_LATENCY_M64US,      /* > 64 us */
2722 +};
2723 +
2724 +/* Link Control and Status Register */
2725 +#define PCIE_LCTLSTS(X)                     (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x80)
2726 +#define PCIE_LCTLSTS_ASPM_ENABLE            0x00000003  /* Active State Link PM Control */
2727 +#define PCIE_LCTLSTS_ASPM_ENABLE_S          0
2728 +#define PCIE_LCTLSTS_RCB128                 0x00000008  /* Read Completion Boundary 128*/
2729 +#define PCIE_LCTLSTS_LINK_DISABLE           0x00000010  /* Link Disable */
2730 +#define PCIE_LCTLSTS_RETRIAN_LINK           0x00000020  /* Retrain Link */
2731 +#define PCIE_LCTLSTS_COM_CLK_CFG            0x00000040  /* Common Clock Configuration */
2732 +#define PCIE_LCTLSTS_EXT_SYNC               0x00000080  /* Extended Synch */
2733 +#define PCIE_LCTLSTS_CLK_PM_EN              0x00000100  /* Enable Clock Powerm Management */
2734 +#define PCIE_LCTLSTS_LINK_SPEED             0x000F0000  /* Link Speed */
2735 +#define PCIE_LCTLSTS_LINK_SPEED_S           16
2736 +#define PCIE_LCTLSTS_NEGOTIATED_LINK_WIDTH  0x03F00000  /* Negotiated Link Width */
2737 +#define PCIE_LCTLSTS_NEGOTIATED_LINK_WIDTH_S 20
2738 +#define PCIE_LCTLSTS_RETRAIN_PENDING        0x08000000  /* Link training is ongoing */
2739 +#define PCIE_LCTLSTS_SLOT_CLK_CFG           0x10000000  /* Slot Clock Configuration */
2740 +#define PCIE_LCTLSTS_DLL_ACTIVE             0x20000000  /* Data Link Layer Active */
2741 +
2742 +/* Slot Capabilities Register */
2743 +#define PCIE_SLCAP(X)                       (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x84)
2744 +
2745 +/* Slot Capabilities */
2746 +#define PCIE_SLCTLSTS(X)                    (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x88)
2747 +
2748 +/* Root Control and Capability Register */
2749 +#define PCIE_RCTLCAP(X)                     (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x8C)
2750 +#define PCIE_RCTLCAP_SERR_ON_CORRECTABLE_ERR  0x00000001   /* #SERR on COR-ERR */
2751 +#define PCIE_RCTLCAP_SERR_ON_NONFATAL_ERR     0x00000002   /* #SERR on Non-Fatal ERR */
2752 +#define PCIE_RCTLCAP_SERR_ON_FATAL_ERR        0x00000004   /* #SERR on Fatal ERR */
2753 +#define PCIE_RCTLCAP_PME_INT_EN               0x00000008   /* PME Interrupt Enable */
2754 +#define PCIE_RCTLCAP_SERR_ENABLE    (PCIE_RCTLCAP_SERR_ON_CORRECTABLE_ERR | \
2755 +                                     PCIE_RCTLCAP_SERR_ON_NONFATAL_ERR | PCIE_RCTLCAP_SERR_ON_FATAL_ERR)
2756 +/* Root Status Register */
2757 +#define PCIE_RSTS(X)                          (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x90)
2758 +#define PCIE_RSTS_PME_REQ_ID                   0x0000FFFF   /* PME Request ID */
2759 +#define PCIE_RSTS_PME_REQ_ID_S                 0
2760 +#define PCIE_RSTS_PME_STATUS                   0x00010000   /* PME Status */
2761 +#define PCIE_RSTS_PME_PENDING                  0x00020000   /* PME Pending */
2762 +
2763 +/* PCI Express Enhanced Capability Header */
2764 +#define PCIE_ENHANCED_CAP(X)                (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x100)
2765 +#define PCIE_ENHANCED_CAP_ID                 0x0000FFFF  /* PCI Express Extended Capability ID */
2766 +#define PCIE_ENHANCED_CAP_ID_S               0
2767 +#define PCIE_ENHANCED_CAP_VER                0x000F0000  /* Capability Version */
2768 +#define PCIE_ENHANCED_CAP_VER_S              16
2769 +#define PCIE_ENHANCED_CAP_NEXT_OFFSET        0xFFF00000  /* Next Capability Offset */
2770 +#define PCIE_ENHANCED_CAP_NEXT_OFFSET_S      20
2771 +
2772 +/* Uncorrectable Error Status Register */
2773 +#define PCIE_UES_R(X)                       (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x104)
2774 +#define PCIE_DATA_LINK_PROTOCOL_ERR          0x00000010  /* Data Link Protocol Error Status */
2775 +#define PCIE_SURPRISE_DOWN_ERROR             0x00000020  /* Surprise Down Error Status */
2776 +#define PCIE_POISONED_TLP                    0x00001000  /* Poisoned TLP Status */
2777 +#define PCIE_FC_PROTOCOL_ERR                 0x00002000  /* Flow Control Protocol Error Status */
2778 +#define PCIE_COMPLETION_TIMEOUT              0x00004000  /* Completion Timeout Status */
2779 +#define PCIE_COMPLETOR_ABORT                 0x00008000  /* Completer Abort Error */
2780 +#define PCIE_UNEXPECTED_COMPLETION           0x00010000  /* Unexpected Completion Status */
2781 +#define PCIE_RECEIVER_OVERFLOW               0x00020000  /* Receive Overflow Status */
2782 +#define PCIE_MALFORNED_TLP                   0x00040000  /* Malformed TLP Stauts */
2783 +#define PCIE_ECRC_ERR                        0x00080000  /* ECRC Error Stauts */
2784 +#define PCIE_UR_REQ                          0x00100000  /* Unsupported Request Error Status */
2785 +#define PCIE_ALL_UNCORRECTABLE_ERR    (PCIE_DATA_LINK_PROTOCOL_ERR | PCIE_SURPRISE_DOWN_ERROR | \
2786 +                         PCIE_POISONED_TLP | PCIE_FC_PROTOCOL_ERR | PCIE_COMPLETION_TIMEOUT |   \
2787 +                         PCIE_COMPLETOR_ABORT | PCIE_UNEXPECTED_COMPLETION | PCIE_RECEIVER_OVERFLOW |\
2788 +                         PCIE_MALFORNED_TLP | PCIE_ECRC_ERR | PCIE_UR_REQ)
2789 +
2790 +/* Uncorrectable Error Mask Register, Mask means no report */
2791 +#define PCIE_UEMR(X)                        (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x108)
2792 +
2793 +/* Uncorrectable Error Severity Register */
2794 +#define PCIE_UESR(X)                        (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x10C)
2795 +
2796 +/* Correctable Error Status Register */
2797 +#define PCIE_CESR(X)                        (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x110)
2798 +#define PCIE_RX_ERR                          0x00000001  /* Receive Error Status */
2799 +#define PCIE_BAD_TLP                         0x00000040  /* Bad TLP Status */
2800 +#define PCIE_BAD_DLLP                        0x00000080  /* Bad DLLP Status */
2801 +#define PCIE_REPLAY_NUM_ROLLOVER             0x00000100  /* Replay Number Rollover Status */
2802 +#define PCIE_REPLAY_TIMER_TIMEOUT_ERR        0x00001000  /* Reply Timer Timeout Status */
2803 +#define PCIE_ADVISORY_NONFTAL_ERR            0x00002000  /* Advisory Non-Fatal Error Status */
2804 +#define PCIE_CORRECTABLE_ERR        (PCIE_RX_ERR | PCIE_BAD_TLP | PCIE_BAD_DLLP | PCIE_REPLAY_NUM_ROLLOVER |\
2805 +                                     PCIE_REPLAY_TIMER_TIMEOUT_ERR | PCIE_ADVISORY_NONFTAL_ERR)
2806 +
2807 +/* Correctable Error Mask Register */
2808 +#define PCIE_CEMR(X)                        (volatile u32*)(PCIE_RC_CFG_BASE + 0x114)
2809 +
2810 +/* Advanced Error Capabilities and Control Register */
2811 +#define PCIE_AECCR(X)                       (volatile u32*)(PCIE_RC_CFG_BASE + 0x118)
2812 +#define PCIE_AECCR_FIRST_ERR_PTR            0x0000001F  /* First Error Pointer */
2813 +#define PCIE_AECCR_FIRST_ERR_PTR_S          0
2814 +#define PCIE_AECCR_ECRC_GEN_CAP             0x00000020  /* ECRC Generation Capable */
2815 +#define PCIE_AECCR_ECRC_GEN_EN              0x00000040  /* ECRC Generation Enable */
2816 +#define PCIE_AECCR_ECRC_CHECK_CAP           0x00000080  /* ECRC Check Capable */
2817 +#define PCIE_AECCR_ECRC_CHECK_EN            0x00000100  /* ECRC Check Enable */
2818 +
2819 +/* Header Log Register 1 */
2820 +#define PCIE_HLR1(X)                        (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x11C)
2821 +
2822 +/* Header Log Register 2 */
2823 +#define PCIE_HLR2(X)                        (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x120)
2824 +
2825 +/* Header Log Register 3 */
2826 +#define PCIE_HLR3(X)                        (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x124)
2827 +
2828 +/* Header Log Register 4 */
2829 +#define PCIE_HLR4(X)                        (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x128)
2830 +
2831 +/* Root Error Command Register */
2832 +#define PCIE_RECR(X)                        (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x12C)
2833 +#define PCIE_RECR_CORRECTABLE_ERR_REPORT_EN  0x00000001 /* COR-ERR */
2834 +#define PCIE_RECR_NONFATAL_ERR_REPORT_EN     0x00000002 /* Non-Fatal ERR */
2835 +#define PCIE_RECR_FATAL_ERR_REPORT_EN        0x00000004 /* Fatal ERR */
2836 +#define PCIE_RECR_ERR_REPORT_EN  (PCIE_RECR_CORRECTABLE_ERR_REPORT_EN | \
2837 +                PCIE_RECR_NONFATAL_ERR_REPORT_EN | PCIE_RECR_FATAL_ERR_REPORT_EN)
2838 +
2839 +/* Root Error Status Register */
2840 +#define PCIE_RESR(X)                            (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x130)
2841 +#define PCIE_RESR_CORRECTABLE_ERR                0x00000001   /* COR-ERR Receveid */
2842 +#define PCIE_RESR_MULTI_CORRECTABLE_ERR          0x00000002   /* Multiple COR-ERR Received */
2843 +#define PCIE_RESR_FATAL_NOFATAL_ERR              0x00000004   /* ERR Fatal/Non-Fatal Received */
2844 +#define PCIE_RESR_MULTI_FATAL_NOFATAL_ERR        0x00000008   /* Multiple ERR Fatal/Non-Fatal Received */
2845 +#define PCIE_RESR_FIRST_UNCORRECTABLE_FATAL_ERR  0x00000010   /* First UN-COR Fatal */
2846 +#define PCIR_RESR_NON_FATAL_ERR                  0x00000020   /* Non-Fatal Error Message Received */
2847 +#define PCIE_RESR_FATAL_ERR                      0x00000040   /* Fatal Message Received */
2848 +#define PCIE_RESR_AER_INT_MSG_NUM                0xF8000000   /* Advanced Error Interrupt Message Number */
2849 +#define PCIE_RESR_AER_INT_MSG_NUM_S              27
2850 +
2851 +/* Error Source Indentification Register */
2852 +#define PCIE_ESIR(X)                            (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x134)
2853 +#define PCIE_ESIR_CORRECTABLE_ERR_SRC_ID         0x0000FFFF
2854 +#define PCIE_ESIR_CORRECTABLE_ERR_SRC_ID_S       0
2855 +#define PCIE_ESIR_FATAL_NON_FATAL_SRC_ID         0xFFFF0000
2856 +#define PCIE_ESIR_FATAL_NON_FATAL_SRC_ID_S       16
2857 +
2858 +/* VC Enhanced Capability Header */
2859 +#define PCIE_VC_ECH(X)                          (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x140)
2860 +
2861 +/* Port VC Capability Register */
2862 +#define PCIE_PVC1(X)                            (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x144)
2863 +#define PCIE_PVC1_EXT_VC_CNT                    0x00000007  /* Extended VC Count */
2864 +#define PCIE_PVC1_EXT_VC_CNT_S                  0
2865 +#define PCIE_PVC1_LOW_PRI_EXT_VC_CNT            0x00000070  /* Low Priority Extended VC Count */
2866 +#define PCIE_PVC1_LOW_PRI_EXT_VC_CNT_S          4
2867 +#define PCIE_PVC1_REF_CLK                       0x00000300  /* Reference Clock */
2868 +#define PCIE_PVC1_REF_CLK_S                     8
2869 +#define PCIE_PVC1_PORT_ARB_TAB_ENTRY_SIZE       0x00000C00  /* Port Arbitration Table Entry Size */
2870 +#define PCIE_PVC1_PORT_ARB_TAB_ENTRY_SIZE_S     10
2871 +
2872 +/* Extended Virtual Channel Count Defintion */
2873 +#define PCIE_EXT_VC_CNT_MIN   0
2874 +#define PCIE_EXT_VC_CNT_MAX   7
2875 +
2876 +/* Port Arbitration Table Entry Size Definition */
2877 +enum {
2878 +    PCIE_PORT_ARB_TAB_ENTRY_SIZE_S1BIT = 0,
2879 +    PCIE_PORT_ARB_TAB_ENTRY_SIZE_S2BIT,
2880 +    PCIE_PORT_ARB_TAB_ENTRY_SIZE_S4BIT,
2881 +    PCIE_PORT_ARB_TAB_ENTRY_SIZE_S8BIT,
2882 +};
2883 +
2884 +/* Port VC Capability Register 2 */
2885 +#define PCIE_PVC2(X)                        (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x148)
2886 +#define PCIE_PVC2_VC_ARB_16P_FIXED_WRR      0x00000001  /* HW Fixed arbitration, 16 phase WRR */
2887 +#define PCIE_PVC2_VC_ARB_32P_WRR            0x00000002  /* 32 phase WRR */
2888 +#define PCIE_PVC2_VC_ARB_64P_WRR            0x00000004  /* 64 phase WRR */
2889 +#define PCIE_PVC2_VC_ARB_128P_WRR           0x00000008  /* 128 phase WRR */
2890 +#define PCIE_PVC2_VC_ARB_WRR                0x0000000F
2891 +#define PCIE_PVC2_VC_ARB_TAB_OFFSET         0xFF000000  /* VC arbitration table offset, not support */
2892 +#define PCIE_PVC2_VC_ARB_TAB_OFFSET_S       24
2893 +
2894 +/* Port VC Control and Status Register */
2895 +#define PCIE_PVCCRSR(X)                     (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x14C)
2896 +#define PCIE_PVCCRSR_LOAD_VC_ARB_TAB         0x00000001  /* Load VC Arbitration Table */
2897 +#define PCIE_PVCCRSR_VC_ARB_SEL              0x0000000E  /* VC Arbitration Select */
2898 +#define PCIE_PVCCRSR_VC_ARB_SEL_S            1
2899 +#define PCIE_PVCCRSR_VC_ARB_TAB_STATUS       0x00010000  /* Arbitration Status */
2900 +
2901 +/* VC0 Resource Capability Register */
2902 +#define PCIE_VC0_RC(X)                       (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x150)
2903 +#define PCIE_VC0_RC_PORT_ARB_HW_FIXED        0x00000001  /* HW Fixed arbitration */
2904 +#define PCIE_VC0_RC_PORT_ARB_32P_WRR         0x00000002  /* 32 phase WRR */
2905 +#define PCIE_VC0_RC_PORT_ARB_64P_WRR         0x00000004  /* 64 phase WRR */
2906 +#define PCIE_VC0_RC_PORT_ARB_128P_WRR        0x00000008  /* 128 phase WRR */
2907 +#define PCIE_VC0_RC_PORT_ARB_TM_128P_WRR     0x00000010  /* Time-based 128 phase WRR */
2908 +#define PCIE_VC0_RC_PORT_ARB_TM_256P_WRR     0x00000020  /* Time-based 256 phase WRR */
2909 +#define PCIE_VC0_RC_PORT_ARB          (PCIE_VC0_RC_PORT_ARB_HW_FIXED | PCIE_VC0_RC_PORT_ARB_32P_WRR |\
2910 +                        PCIE_VC0_RC_PORT_ARB_64P_WRR | PCIE_VC0_RC_PORT_ARB_128P_WRR | \
2911 +                        PCIE_VC0_RC_PORT_ARB_TM_128P_WRR | PCIE_VC0_RC_PORT_ARB_TM_256P_WRR)
2912 +
2913 +#define PCIE_VC0_RC_REJECT_SNOOP             0x00008000  /* Reject Snoop Transactioin */
2914 +#define PCIE_VC0_RC_MAX_TIMESLOTS            0x007F0000  /* Maximum time Slots */
2915 +#define PCIE_VC0_RC_MAX_TIMESLOTS_S          16
2916 +#define PCIE_VC0_RC_PORT_ARB_TAB_OFFSET      0xFF000000  /* Port Arbitration Table Offset */
2917 +#define PCIE_VC0_RC_PORT_ARB_TAB_OFFSET_S    24
2918 +
2919 +/* VC0 Resource Control Register */
2920 +#define PCIE_VC0_RC0(X)                      (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x154)
2921 +#define PCIE_VC0_RC0_TVM0                    0x00000001  /* TC0 and VC0 */
2922 +#define PCIE_VC0_RC0_TVM1                    0x00000002  /* TC1 and VC1 */
2923 +#define PCIE_VC0_RC0_TVM2                    0x00000004  /* TC2 and VC2 */
2924 +#define PCIE_VC0_RC0_TVM3                    0x00000008  /* TC3 and VC3 */
2925 +#define PCIE_VC0_RC0_TVM4                    0x00000010  /* TC4 and VC4 */
2926 +#define PCIE_VC0_RC0_TVM5                    0x00000020  /* TC5 and VC5 */
2927 +#define PCIE_VC0_RC0_TVM6                    0x00000040  /* TC6 and VC6 */
2928 +#define PCIE_VC0_RC0_TVM7                    0x00000080  /* TC7 and VC7 */
2929 +#define PCIE_VC0_RC0_TC_VC                   0x000000FF  /* TC/VC mask */
2930 +
2931 +#define PCIE_VC0_RC0_LOAD_PORT_ARB_TAB       0x00010000  /* Load Port Arbitration Table */
2932 +#define PCIE_VC0_RC0_PORT_ARB_SEL            0x000E0000  /* Port Arbitration Select */
2933 +#define PCIE_VC0_RC0_PORT_ARB_SEL_S          17
2934 +#define PCIE_VC0_RC0_VC_ID                   0x07000000  /* VC ID */
2935 +#define PCIE_VC0_RC0_VC_ID_S                 24
2936 +#define PCIE_VC0_RC0_VC_EN                   0x80000000  /* VC Enable */
2937 +
2938 +/* VC0 Resource Status Register */
2939 +#define PCIE_VC0_RSR0(X)                     (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x158)
2940 +#define PCIE_VC0_RSR0_PORT_ARB_TAB_STATUS    0x00010000  /* Port Arbitration Table Status,not used */
2941 +#define PCIE_VC0_RSR0_VC_NEG_PENDING         0x00020000  /* VC Negotiation Pending */
2942 +
2943 +/* Ack Latency Timer and Replay Timer Register */
2944 +#define PCIE_ALTRT(X)                         (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x700)
2945 +#define PCIE_ALTRT_ROUND_TRIP_LATENCY_LIMIT   0x0000FFFF  /* Round Trip Latency Time Limit */
2946 +#define PCIE_ALTRT_ROUND_TRIP_LATENCY_LIMIT_S 0
2947 +#define PCIE_ALTRT_REPLAY_TIME_LIMIT          0xFFFF0000  /* Replay Time Limit */
2948 +#define PCIE_ALTRT_REPLAY_TIME_LIMIT_S        16
2949 +
2950 +/* Other Message Register */
2951 +#define PCIE_OMR(X)                          (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x704)
2952 +
2953 +/* Port Force Link Register */
2954 +#define PCIE_PFLR(X)                         (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x708)
2955 +#define PCIE_PFLR_LINK_NUM                   0x000000FF  /* Link Number */
2956 +#define PCIE_PFLR_LINK_NUM_S                 0
2957 +#define PCIE_PFLR_FORCE_LINK                 0x00008000  /* Force link */
2958 +#define PCIE_PFLR_LINK_STATE                 0x003F0000  /* Link State */
2959 +#define PCIE_PFLR_LINK_STATE_S               16
2960 +#define PCIE_PFLR_LOW_POWER_ENTRY_CNT        0xFF000000  /* Low Power Entrance Count, only for EP */
2961 +#define PCIE_PFLR_LOW_POWER_ENTRY_CNT_S      24
2962 +
2963 +/* Ack Frequency Register */
2964 +#define PCIE_AFR(X)                          (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x70C)
2965 +#define PCIE_AFR_AF                          0x000000FF  /* Ack Frequency */
2966 +#define PCIE_AFR_AF_S                        0
2967 +#define PCIE_AFR_FTS_NUM                     0x0000FF00  /* The number of Fast Training Sequence from L0S to L0 */
2968 +#define PCIE_AFR_FTS_NUM_S                   8
2969 +#define PCIE_AFR_COM_FTS_NUM                 0x00FF0000  /* N_FTS; when common clock is used*/
2970 +#define PCIE_AFR_COM_FTS_NUM_S               16
2971 +#define PCIE_AFR_L0S_ENTRY_LATENCY           0x07000000  /* L0s Entrance Latency */
2972 +#define PCIE_AFR_L0S_ENTRY_LATENCY_S         24
2973 +#define PCIE_AFR_L1_ENTRY_LATENCY            0x38000000  /* L1 Entrance Latency */
2974 +#define PCIE_AFR_L1_ENTRY_LATENCY_S          27
2975 +#define PCIE_AFR_FTS_NUM_DEFAULT             32
2976 +#define PCIE_AFR_L0S_ENTRY_LATENCY_DEFAULT   7
2977 +#define PCIE_AFR_L1_ENTRY_LATENCY_DEFAULT    5
2978 +
2979 +/* Port Link Control Register */
2980 +#define PCIE_PLCR(X)                         (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x710)
2981 +#define PCIE_PLCR_OTHER_MSG_REQ              0x00000001  /* Other Message Request */
2982 +#define PCIE_PLCR_SCRAMBLE_DISABLE           0x00000002  /* Scramble Disable */
2983 +#define PCIE_PLCR_LOOPBACK_EN                0x00000004  /* Loopback Enable */
2984 +#define PCIE_PLCR_LTSSM_HOT_RST              0x00000008  /* Force LTSSM to the hot reset */
2985 +#define PCIE_PLCR_DLL_LINK_EN                0x00000020  /* Enable Link initialization */
2986 +#define PCIE_PLCR_FAST_LINK_SIM_EN           0x00000080  /* Sets all internal timers to fast mode for simulation purposes */
2987 +#define PCIE_PLCR_LINK_MODE                  0x003F0000  /* Link Mode Enable Mask */
2988 +#define PCIE_PLCR_LINK_MODE_S                16
2989 +#define PCIE_PLCR_CORRUPTED_CRC_EN           0x02000000  /* Enabled Corrupt CRC */
2990 +
2991 +/* Lane Skew Register */
2992 +#define PCIE_LSR(X)                          (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x714)
2993 +#define PCIE_LSR_LANE_SKEW_NUM               0x00FFFFFF  /* Insert Lane Skew for Transmit, not applicable */
2994 +#define PCIE_LSR_LANE_SKEW_NUM_S             0
2995 +#define PCIE_LSR_FC_DISABLE                  0x01000000  /* Disable of Flow Control */
2996 +#define PCIE_LSR_ACKNAK_DISABLE              0x02000000  /* Disable of Ack/Nak */
2997 +#define PCIE_LSR_LANE_DESKEW_DISABLE         0x80000000  /* Disable of Lane-to-Lane Skew */
2998 +
2999 +/* Symbol Number Register */
3000 +#define PCIE_SNR(X)                          (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x718)
3001 +#define PCIE_SNR_TS                          0x0000000F  /* Number of TS Symbol */
3002 +#define PCIE_SNR_TS_S                        0
3003 +#define PCIE_SNR_SKP                         0x00000700  /* Number of SKP Symbol */
3004 +#define PCIE_SNR_SKP_S                       8
3005 +#define PCIE_SNR_REPLAY_TIMER                0x0007C000  /* Timer Modifier for Replay Timer */
3006 +#define PCIE_SNR_REPLAY_TIMER_S              14
3007 +#define PCIE_SNR_ACKNAK_LATENCY_TIMER        0x00F80000  /* Timer Modifier for Ack/Nak Latency Timer */
3008 +#define PCIE_SNR_ACKNAK_LATENCY_TIMER_S      19
3009 +#define PCIE_SNR_FC_TIMER                    0x1F000000  /* Timer Modifier for Flow Control Watchdog Timer */
3010 +#define PCIE_SNR_FC_TIMER_S                  28
3011 +
3012 +/* Symbol Timer Register and Filter Mask Register 1 */
3013 +#define PCIE_STRFMR(X)                      (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x71C)
3014 +#define PCIE_STRFMR_SKP_INTERVAL            0x000007FF  /* SKP lnterval Value */
3015 +#define PCIE_STRFMR_SKP_INTERVAL_S          0
3016 +#define PCIE_STRFMR_FC_WDT_DISABLE          0x00008000  /* Disable of FC Watchdog Timer */
3017 +#define PCIE_STRFMR_TLP_FUNC_MISMATCH_OK    0x00010000  /* Mask Function Mismatch Filtering for Incoming Requests */
3018 +#define PCIE_STRFMR_POISONED_TLP_OK         0x00020000  /* Mask Poisoned TLP Filtering */
3019 +#define PCIE_STRFMR_BAR_MATCH_OK            0x00040000  /* Mask BAR Match Filtering */
3020 +#define PCIE_STRFMR_TYPE1_CFG_REQ_OK        0x00080000  /* Mask Type 1 Configuration Request Filtering */
3021 +#define PCIE_STRFMR_LOCKED_REQ_OK           0x00100000  /* Mask Locked Request Filtering */
3022 +#define PCIE_STRFMR_CPL_TAG_ERR_RULES_OK    0x00200000  /* Mask Tag Error Rules for Received Completions */
3023 +#define PCIE_STRFMR_CPL_REQUESTOR_ID_MISMATCH_OK 0x00400000  /* Mask Requester ID Mismatch Error for Received Completions */
3024 +#define PCIE_STRFMR_CPL_FUNC_MISMATCH_OK         0x00800000  /* Mask Function Mismatch Error for Received Completions */
3025 +#define PCIE_STRFMR_CPL_TC_MISMATCH_OK           0x01000000  /* Mask Traffic Class Mismatch Error for Received Completions */
3026 +#define PCIE_STRFMR_CPL_ATTR_MISMATCH_OK         0x02000000  /* Mask Attribute Mismatch Error for Received Completions */
3027 +#define PCIE_STRFMR_CPL_LENGTH_MISMATCH_OK       0x04000000  /* Mask Length Mismatch Error for Received Completions */
3028 +#define PCIE_STRFMR_TLP_ECRC_ERR_OK              0x08000000  /* Mask ECRC Error Filtering */
3029 +#define PCIE_STRFMR_CPL_TLP_ECRC_OK              0x10000000  /* Mask ECRC Error Filtering for Completions */
3030 +#define PCIE_STRFMR_RX_TLP_MSG_NO_DROP           0x20000000  /* Send Message TLPs */
3031 +#define PCIE_STRFMR_RX_IO_TRANS_ENABLE           0x40000000  /* Mask Filtering of received I/O Requests */
3032 +#define PCIE_STRFMR_RX_CFG_TRANS_ENABLE          0x80000000  /* Mask Filtering of Received Configuration Requests */
3033 +
3034 +#define PCIE_DEF_SKP_INTERVAL    700             /* 1180 ~1538 , 125MHz * 2, 250MHz * 1 */
3035 +
3036 +/* Filter Masker Register 2 */
3037 +#define PCIE_FMR2(X)                             (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x720)
3038 +#define PCIE_FMR2_VENDOR_MSG0_PASSED_TO_TRGT1    0x00000001  /* Mask RADM Filtering and Error Handling Rules */
3039 +#define PCIE_FMR2_VENDOR_MSG1_PASSED_TO_TRGT1    0x00000002  /* Mask RADM Filtering and Error Handling Rules */
3040 +
3041 +/* Debug Register 0 */
3042 +#define PCIE_DBR0(X)                              (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x728)
3043 +
3044 +/* Debug Register 1 */
3045 +#define PCIE_DBR1(X)                              (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x72C)
3046 +
3047 +/* Transmit Posted FC Credit Status Register */
3048 +#define PCIE_TPFCS(X)                             (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x730)
3049 +#define PCIE_TPFCS_TX_P_DATA_FC_CREDITS           0x00000FFF /* Transmit Posted Data FC Credits */
3050 +#define PCIE_TPFCS_TX_P_DATA_FC_CREDITS_S         0
3051 +#define PCIE_TPFCS_TX_P_HDR_FC_CREDITS            0x000FF000 /* Transmit Posted Header FC Credits */
3052 +#define PCIE_TPFCS_TX_P_HDR_FC_CREDITS_S          12
3053 +
3054 +/* Transmit Non-Posted FC Credit Status */
3055 +#define PCIE_TNPFCS(X)                            (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x734)
3056 +#define PCIE_TNPFCS_TX_NP_DATA_FC_CREDITS         0x00000FFF /* Transmit Non-Posted Data FC Credits */
3057 +#define PCIE_TNPFCS_TX_NP_DATA_FC_CREDITS_S       0
3058 +#define PCIE_TNPFCS_TX_NP_HDR_FC_CREDITS          0x000FF000 /* Transmit Non-Posted Header FC Credits */
3059 +#define PCIE_TNPFCS_TX_NP_HDR_FC_CREDITS_S        12
3060 +
3061 +/* Transmit Complete FC Credit Status Register */
3062 +#define PCIE_TCFCS(X)                             (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x738)
3063 +#define PCIE_TCFCS_TX_CPL_DATA_FC_CREDITS         0x00000FFF /* Transmit Completion Data FC Credits */
3064 +#define PCIE_TCFCS_TX_CPL_DATA_FC_CREDITS_S       0
3065 +#define PCIE_TCFCS_TX_CPL_HDR_FC_CREDITS          0x000FF000 /* Transmit Completion Header FC Credits */
3066 +#define PCIE_TCFCS_TX_CPL_HDR_FC_CREDITS_S        12
3067 +
3068 +/* Queue Status Register */
3069 +#define PCIE_QSR(X)                              (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x73C)
3070 +#define PCIE_QSR_WAIT_UPDATE_FC_DLL               0x00000001 /* Received TLP FC Credits Not Returned */
3071 +#define PCIE_QSR_TX_RETRY_BUF_NOT_EMPTY           0x00000002 /* Transmit Retry Buffer Not Empty */
3072 +#define PCIE_QSR_RX_QUEUE_NOT_EMPTY               0x00000004 /* Received Queue Not Empty */
3073 +
3074 +/* VC Transmit Arbitration Register 1 */
3075 +#define PCIE_VCTAR1(X)                          (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x740)
3076 +#define PCIE_VCTAR1_WRR_WEIGHT_VC0               0x000000FF /* WRR Weight for VC0 */
3077 +#define PCIE_VCTAR1_WRR_WEIGHT_VC1               0x0000FF00 /* WRR Weight for VC1 */
3078 +#define PCIE_VCTAR1_WRR_WEIGHT_VC2               0x00FF0000 /* WRR Weight for VC2 */
3079 +#define PCIE_VCTAR1_WRR_WEIGHT_VC3               0xFF000000 /* WRR Weight for VC3 */
3080 +
3081 +/* VC Transmit Arbitration Register 2 */
3082 +#define PCIE_VCTAR2(X)                          (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x744)
3083 +#define PCIE_VCTAR2_WRR_WEIGHT_VC4               0x000000FF /* WRR Weight for VC4 */
3084 +#define PCIE_VCTAR2_WRR_WEIGHT_VC5               0x0000FF00 /* WRR Weight for VC5 */
3085 +#define PCIE_VCTAR2_WRR_WEIGHT_VC6               0x00FF0000 /* WRR Weight for VC6 */
3086 +#define PCIE_VCTAR2_WRR_WEIGHT_VC7               0xFF000000 /* WRR Weight for VC7 */
3087 +
3088 +/* VC0 Posted Receive Queue Control Register */
3089 +#define PCIE_VC0_PRQCR(X)                       (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x748)
3090 +#define PCIE_VC0_PRQCR_P_DATA_CREDITS            0x00000FFF /* VC0 Posted Data Credits */
3091 +#define PCIE_VC0_PRQCR_P_DATA_CREDITS_S          0
3092 +#define PCIE_VC0_PRQCR_P_HDR_CREDITS             0x000FF000 /* VC0 Posted Header Credits */
3093 +#define PCIE_VC0_PRQCR_P_HDR_CREDITS_S           12
3094 +#define PCIE_VC0_PRQCR_P_TLP_QUEUE_MODE          0x00E00000 /* VC0 Posted TLP Queue Mode */
3095 +#define PCIE_VC0_PRQCR_P_TLP_QUEUE_MODE_S        20
3096 +#define PCIE_VC0_PRQCR_TLP_RELAX_ORDER           0x40000000 /* TLP Type Ordering for VC0 */
3097 +#define PCIE_VC0_PRQCR_VC_STRICT_ORDER           0x80000000 /* VC0 Ordering for Receive Queues */
3098 +
3099 +/* VC0 Non-Posted Receive Queue Control */
3100 +#define PCIE_VC0_NPRQCR(X)                      (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x74C)
3101 +#define PCIE_VC0_NPRQCR_NP_DATA_CREDITS          0x00000FFF /* VC0 Non-Posted Data Credits */
3102 +#define PCIE_VC0_NPRQCR_NP_DATA_CREDITS_S        0
3103 +#define PCIE_VC0_NPRQCR_NP_HDR_CREDITS           0x000FF000 /* VC0 Non-Posted Header Credits */
3104 +#define PCIE_VC0_NPRQCR_NP_HDR_CREDITS_S         12
3105 +#define PCIE_VC0_NPRQCR_NP_TLP_QUEUE_MODE        0x00E00000 /* VC0 Non-Posted TLP Queue Mode */
3106 +#define PCIE_VC0_NPRQCR_NP_TLP_QUEUE_MODE_S      20
3107 +
3108 +/* VC0 Completion Receive Queue Control */
3109 +#define PCIE_VC0_CRQCR(X)                       (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x750)
3110 +#define PCIE_VC0_CRQCR_CPL_DATA_CREDITS          0x00000FFF /* VC0 Completion TLP Queue Mode */
3111 +#define PCIE_VC0_CRQCR_CPL_DATA_CREDITS_S        0
3112 +#define PCIE_VC0_CRQCR_CPL_HDR_CREDITS           0x000FF000 /* VC0 Completion Header Credits */
3113 +#define PCIE_VC0_CRQCR_CPL_HDR_CREDITS_S         12
3114 +#define PCIE_VC0_CRQCR_CPL_TLP_QUEUE_MODE        0x00E00000 /* VC0 Completion Data Credits */
3115 +#define PCIE_VC0_CRQCR_CPL_TLP_QUEUE_MODE_S      21
3116 +
3117 +/* Applicable to the above three registers */
3118 +enum {
3119 +    PCIE_VC0_TLP_QUEUE_MODE_STORE_FORWARD = 1,
3120 +    PCIE_VC0_TLP_QUEUE_MODE_CUT_THROUGH   = 2,
3121 +    PCIE_VC0_TLP_QUEUE_MODE_BYPASS        = 4,
3122 +};
3123 +
3124 +/* VC0 Posted Buffer Depth Register */
3125 +#define PCIE_VC0_PBD(X)                        (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x7A8)
3126 +#define PCIE_VC0_PBD_P_DATA_QUEUE_ENTRIES       0x00003FFF /* VC0 Posted Data Queue Depth */
3127 +#define PCIE_VC0_PBD_P_DATA_QUEUE_ENTRIES_S     0
3128 +#define PCIE_VC0_PBD_P_HDR_QUEUE_ENTRIES        0x03FF0000 /* VC0 Posted Header Queue Depth */
3129 +#define PCIE_VC0_PBD_P_HDR_QUEUE_ENTRIES_S      16
3130 +
3131 +/* VC0 Non-Posted Buffer Depth Register */
3132 +#define PCIE_VC0_NPBD(X)                       (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x7AC)
3133 +#define PCIE_VC0_NPBD_NP_DATA_QUEUE_ENTRIES     0x00003FFF /* VC0 Non-Posted Data Queue Depth */
3134 +#define PCIE_VC0_NPBD_NP_DATA_QUEUE_ENTRIES_S   0
3135 +#define PCIE_VC0_NPBD_NP_HDR_QUEUE_ENTRIES      0x03FF0000 /* VC0 Non-Posted Header Queue Depth */
3136 +#define PCIE_VC0_NPBD_NP_HDR_QUEUE_ENTRIES_S    16
3137 +
3138 +/* VC0 Completion Buffer Depth Register */
3139 +#define PCIE_VC0_CBD(X)                        (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x7B0)
3140 +#define PCIE_VC0_CBD_CPL_DATA_QUEUE_ENTRIES     0x00003FFF /* C0 Completion Data Queue Depth */
3141 +#define PCIE_VC0_CBD_CPL_DATA_QUEUE_ENTRIES_S   0
3142 +#define PCIE_VC0_CBD_CPL_HDR_QUEUE_ENTRIES      0x03FF0000 /* VC0 Completion Header Queue Depth */
3143 +#define PCIE_VC0_CBD_CPL_HDR_QUEUE_ENTRIES_S    16
3144 +
3145 +/* PHY Status Register, all zeros in VR9 */
3146 +#define PCIE_PHYSR(X)                           (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x810)
3147 +
3148 +/* PHY Control Register, all zeros in VR9 */
3149 +#define PCIE_PHYCR(X)                           (volatile u32*)(PCIE_RC_PORT_TO_BASE(X) + 0x814)
3150 +
3151 +/*
3152 + * PCIe PDI PHY register definition, suppose all the following
3153 + * stuff is confidential.
3154 + * XXX, detailed bit definition
3155 + */
3156 +#define        PCIE_PHY_PLL_CTRL1(X)       (PCIE_PHY_PORT_TO_BASE(X) + (0x22 << 1))
3157 +#define        PCIE_PHY_PLL_CTRL2(X)       (PCIE_PHY_PORT_TO_BASE(X) + (0x23 << 1))
3158 +#define        PCIE_PHY_PLL_CTRL3(X)       (PCIE_PHY_PORT_TO_BASE(X) + (0x24 << 1))
3159 +#define        PCIE_PHY_PLL_CTRL4(X)       (PCIE_PHY_PORT_TO_BASE(X) + (0x25 << 1))
3160 +#define        PCIE_PHY_PLL_CTRL5(X)       (PCIE_PHY_PORT_TO_BASE(X) + (0x26 << 1))
3161 +#define        PCIE_PHY_PLL_CTRL6(X)       (PCIE_PHY_PORT_TO_BASE(X) + (0x27 << 1))
3162 +#define        PCIE_PHY_PLL_CTRL7(X)       (PCIE_PHY_PORT_TO_BASE(X) + (0x28 << 1))
3163 +#define        PCIE_PHY_PLL_A_CTRL1(X)     (PCIE_PHY_PORT_TO_BASE(X) + (0x29 << 1))
3164 +#define        PCIE_PHY_PLL_A_CTRL2(X)     (PCIE_PHY_PORT_TO_BASE(X) + (0x2A << 1))
3165 +#define        PCIE_PHY_PLL_A_CTRL3(X)     (PCIE_PHY_PORT_TO_BASE(X) + (0x2B << 1))
3166 +#define        PCIE_PHY_PLL_STATUS(X)      (PCIE_PHY_PORT_TO_BASE(X) + (0x2C << 1))
3167 +
3168 +#define PCIE_PHY_TX1_CTRL1(X)       (PCIE_PHY_PORT_TO_BASE(X) + (0x30 << 1))
3169 +#define PCIE_PHY_TX1_CTRL2(X)       (PCIE_PHY_PORT_TO_BASE(X) + (0x31 << 1))
3170 +#define PCIE_PHY_TX1_CTRL3(X)       (PCIE_PHY_PORT_TO_BASE(X) + (0x32 << 1))
3171 +#define PCIE_PHY_TX1_A_CTRL1(X)     (PCIE_PHY_PORT_TO_BASE(X) + (0x33 << 1))
3172 +#define PCIE_PHY_TX1_A_CTRL2(X)     (PCIE_PHY_PORT_TO_BASE(X) + (0x34 << 1))
3173 +#define PCIE_PHY_TX1_MOD1(X)        (PCIE_PHY_PORT_TO_BASE(X) + (0x35 << 1))
3174 +#define PCIE_PHY_TX1_MOD2(X)        (PCIE_PHY_PORT_TO_BASE(X) + (0x36 << 1))
3175 +#define PCIE_PHY_TX1_MOD3(X)        (PCIE_PHY_PORT_TO_BASE(X) + (0x37 << 1))
3176 +
3177 +#define PCIE_PHY_TX2_CTRL1(X)       (PCIE_PHY_PORT_TO_BASE(X) + (0x38 << 1))
3178 +#define PCIE_PHY_TX2_CTRL2(X)       (PCIE_PHY_PORT_TO_BASE(X) + (0x39 << 1))
3179 +#define PCIE_PHY_TX2_A_CTRL1(X)     (PCIE_PHY_PORT_TO_BASE(X) + (0x3B << 1))
3180 +#define PCIE_PHY_TX2_A_CTRL2(X)     (PCIE_PHY_PORT_TO_BASE(X) + (0x3C << 1))
3181 +#define PCIE_PHY_TX2_MOD1(X)        (PCIE_PHY_PORT_TO_BASE(X) + (0x3D << 1))
3182 +#define PCIE_PHY_TX2_MOD2(X)        (PCIE_PHY_PORT_TO_BASE(X) + (0x3E << 1))
3183 +#define PCIE_PHY_TX2_MOD3(X)        (PCIE_PHY_PORT_TO_BASE(X) + (0x3F << 1))
3184 +
3185 +#define PCIE_PHY_RX1_CTRL1(X)       (PCIE_PHY_PORT_TO_BASE(X) + (0x50 << 1))
3186 +#define PCIE_PHY_RX1_CTRL2(X)       (PCIE_PHY_PORT_TO_BASE(X) + (0x51 << 1))
3187 +#define PCIE_PHY_RX1_CDR(X)         (PCIE_PHY_PORT_TO_BASE(X) + (0x52 << 1))
3188 +#define PCIE_PHY_RX1_EI(X)          (PCIE_PHY_PORT_TO_BASE(X) + (0x53 << 1))
3189 +#define PCIE_PHY_RX1_A_CTRL(X)      (PCIE_PHY_PORT_TO_BASE(X) + (0x55 << 1))
3190 +
3191 +/* Interrupt related stuff */
3192 +#define PCIE_LEGACY_DISABLE 0
3193 +#define PCIE_LEGACY_INTA  1
3194 +#define PCIE_LEGACY_INTB  2
3195 +#define PCIE_LEGACY_INTC  3
3196 +#define PCIE_LEGACY_INTD  4
3197 +#define PCIE_LEGACY_INT_MAX PCIE_LEGACY_INTD
3198 +
3199 +#define PCIE_IRQ_LOCK(lock) do {             \
3200 +    unsigned long flags;                     \
3201 +    spin_lock_irqsave(&(lock), flags);
3202 +#define PCIE_IRQ_UNLOCK(lock)                \
3203 +    spin_unlock_irqrestore(&(lock), flags);  \
3204 +} while (0)
3205 +
3206 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
3207 +#define IRQF_SHARED SA_SHIRQ
3208 +#endif
3209 +
3210 +#define PCIE_MSG_MSI        0x00000001
3211 +#define PCIE_MSG_ISR        0x00000002
3212 +#define PCIE_MSG_FIXUP      0x00000004
3213 +#define PCIE_MSG_READ_CFG   0x00000008
3214 +#define PCIE_MSG_WRITE_CFG  0x00000010
3215 +#define PCIE_MSG_CFG        (PCIE_MSG_READ_CFG | PCIE_MSG_WRITE_CFG)
3216 +#define PCIE_MSG_REG        0x00000020
3217 +#define PCIE_MSG_INIT       0x00000040
3218 +#define PCIE_MSG_ERR        0x00000080
3219 +#define PCIE_MSG_PHY        0x00000100
3220 +#define PCIE_MSG_ANY        0x000001ff
3221 +
3222 +#define IFX_PCIE_PORT0      0
3223 +#define IFX_PCIE_PORT1      1
3224 +
3225 +#ifdef CONFIG_IFX_PCIE_2ND_CORE
3226 +#define IFX_PCIE_CORE_NR    2
3227 +#else
3228 +#define IFX_PCIE_CORE_NR    1
3229 +#endif
3230 +
3231 +//#define IFX_PCIE_ERROR_INT
3232 +
3233 +//#define IFX_PCIE_DBG
3234 +
3235 +#if defined(IFX_PCIE_DBG)
3236 +#define IFX_PCIE_PRINT(_m, _fmt, args...) do {   \
3237 +    if (g_pcie_debug_flag & (_m)) {              \
3238 +        ifx_pcie_debug((_fmt), ##args);          \
3239 +    }                                            \
3240 +} while (0)
3241 +
3242 +#define INLINE
3243 +#else
3244 +#define IFX_PCIE_PRINT(_m, _fmt, args...)   \
3245 +    do {} while(0)
3246 +#define INLINE inline
3247 +#endif
3248 +
3249 +struct ifx_pci_controller {
3250 +       struct pci_controller   pcic;
3251 +
3252 +       /* RC specific, per host bus information */
3253 +       u32   port;  /* Port index, 0 -- 1st core, 1 -- 2nd core */
3254 +};
3255 +
3256 +typedef struct ifx_pcie_ir_irq {
3257 +    const unsigned int irq;
3258 +    const char name[16];
3259 +}ifx_pcie_ir_irq_t;
3260 +
3261 +typedef struct ifx_pcie_legacy_irq{
3262 +    const u32 irq_bit;
3263 +    const int irq;
3264 +}ifx_pcie_legacy_irq_t;
3265 +
3266 +typedef struct ifx_pcie_irq {
3267 +    ifx_pcie_ir_irq_t ir_irq;
3268 +    ifx_pcie_legacy_irq_t legacy_irq[PCIE_LEGACY_INT_MAX];
3269 +}ifx_pcie_irq_t;
3270 +
3271 +extern u32 g_pcie_debug_flag;
3272 +extern void ifx_pcie_debug(const char *fmt, ...);
3273 +extern void pcie_phy_clock_mode_setup(int pcie_port);
3274 +extern void pcie_msi_pic_init(int pcie_port);
3275 +extern u32 ifx_pcie_bus_enum_read_hack(int where, u32 value);
3276 +extern u32 ifx_pcie_bus_enum_write_hack(int where, u32 value);
3277 +
3278 +
3279 +#include <linux/types.h>
3280 +#include <linux/delay.h>
3281 +#include <linux/gpio.h>
3282 +#include <linux/clk.h>
3283 +
3284 +#include <lantiq_soc.h>
3285 +
3286 +#define IFX_PCIE_GPIO_RESET  38
3287 +#define IFX_REG_R32    ltq_r32
3288 +#define IFX_REG_W32    ltq_w32
3289 +#define CONFIG_IFX_PCIE_HW_SWAP
3290 +#define IFX_RCU_AHB_ENDIAN                      ((volatile u32*)(IFX_RCU + 0x004C))
3291 +#define IFX_RCU_RST_REQ                         ((volatile u32*)(IFX_RCU + 0x0010))
3292 +#define IFX_RCU_AHB_BE_PCIE_PDI                  0x00000080  /* Configure PCIE PDI module in big endian*/
3293 +
3294 +#define IFX_RCU                                 (KSEG1 | 0x1F203000)
3295 +#define IFX_RCU_AHB_BE_PCIE_M                    0x00000001  /* Configure AHB master port that connects to PCIe RC in big endian */
3296 +#define IFX_RCU_AHB_BE_PCIE_S                    0x00000010  /* Configure AHB slave port that connects to PCIe RC in little endian */
3297 +#define IFX_RCU_AHB_BE_XBAR_M                    0x00000002  /* Configure AHB master port that connects to XBAR in big endian */
3298 +#define CONFIG_IFX_PCIE_PHY_36MHZ_MODE
3299 +
3300 +#define IFX_PMU1_MODULE_PCIE_PHY   (0)
3301 +#define IFX_PMU1_MODULE_PCIE_CTRL  (1)
3302 +#define IFX_PMU1_MODULE_PDI        (4)
3303 +#define IFX_PMU1_MODULE_MSI        (5)
3304 +
3305 +#define IFX_PMU_MODULE_PCIE_L0_CLK (31)
3306 +
3307 +
3308 +static inline void pcie_ep_gpio_rst_init(int pcie_port)
3309 +{
3310 +}
3311 +
3312 +static inline void pcie_ahb_pmu_setup(void)
3313 +{
3314 +       struct clk *clk;
3315 +       clk = clk_get_sys("ltq_pcie", "ahb");
3316 +       clk_enable(clk);
3317 +       //ltq_pmu_enable(PMU_AHBM | PMU_AHBS);
3318 +}
3319 +
3320 +static inline void pcie_rcu_endian_setup(int pcie_port)
3321 +{
3322 +    u32 reg;
3323 +
3324 +    reg = IFX_REG_R32(IFX_RCU_AHB_ENDIAN);
3325 +#ifdef CONFIG_IFX_PCIE_HW_SWAP
3326 +    reg |= IFX_RCU_AHB_BE_PCIE_M;
3327 +    reg |= IFX_RCU_AHB_BE_PCIE_S;
3328 +    reg &= ~IFX_RCU_AHB_BE_XBAR_M;
3329 +#else
3330 +    reg |= IFX_RCU_AHB_BE_PCIE_M;
3331 +    reg &= ~IFX_RCU_AHB_BE_PCIE_S;
3332 +    reg &= ~IFX_RCU_AHB_BE_XBAR_M;
3333 +#endif /* CONFIG_IFX_PCIE_HW_SWAP */
3334 +    IFX_REG_W32(reg, IFX_RCU_AHB_ENDIAN);
3335 +    IFX_PCIE_PRINT(PCIE_MSG_REG, "%s IFX_RCU_AHB_ENDIAN: 0x%08x\n", __func__, IFX_REG_R32(IFX_RCU_AHB_ENDIAN));
3336 +}
3337 +
3338 +static inline void pcie_phy_pmu_enable(int pcie_port)
3339 +{
3340 +       struct clk *clk;
3341 +       clk = clk_get_sys("ltq_pcie", "phy");
3342 +       clk_enable(clk);
3343 +       //ltq_pmu1_enable(1<<IFX_PMU1_MODULE_PCIE_PHY);
3344 +}
3345 +
3346 +static inline void pcie_phy_pmu_disable(int pcie_port)
3347 +{
3348 +       struct clk *clk;
3349 +       clk = clk_get_sys("ltq_pcie", "phy");
3350 +       clk_disable(clk);
3351 +       //ltq_pmu1_disable(1<<IFX_PMU1_MODULE_PCIE_PHY);
3352 +}
3353 +
3354 +static inline void pcie_pdi_big_endian(int pcie_port)
3355 +{
3356 +    u32 reg;
3357 +
3358 +    /* SRAM2PDI endianness control. */
3359 +    reg = IFX_REG_R32(IFX_RCU_AHB_ENDIAN);
3360 +    /* Config AHB->PCIe and PDI endianness */
3361 +    reg |= IFX_RCU_AHB_BE_PCIE_PDI;
3362 +    IFX_REG_W32(reg, IFX_RCU_AHB_ENDIAN);
3363 +}
3364 +
3365 +static inline void pcie_pdi_pmu_enable(int pcie_port)
3366 +{
3367 +       struct clk *clk;
3368 +       clk = clk_get_sys("ltq_pcie", "pdi");
3369 +       clk_enable(clk);
3370 +       //ltq_pmu1_enable(1<<IFX_PMU1_MODULE_PDI);
3371 +}
3372 +
3373 +static inline void pcie_core_rst_assert(int pcie_port)
3374 +{
3375 +    u32 reg;
3376 +
3377 +    reg = IFX_REG_R32(IFX_RCU_RST_REQ);
3378 +
3379 +    /* Reset PCIe PHY & Core, bit 22, bit 26 may be affected if write it directly  */
3380 +    reg |= 0x00400000;
3381 +    IFX_REG_W32(reg, IFX_RCU_RST_REQ);
3382 +}
3383 +
3384 +static inline void pcie_core_rst_deassert(int pcie_port)
3385 +{
3386 +    u32 reg;
3387 +
3388 +    /* Make sure one micro-second delay */
3389 +    udelay(1);
3390 +
3391 +    /* Reset PCIe PHY & Core, bit 22 */
3392 +    reg = IFX_REG_R32(IFX_RCU_RST_REQ);
3393 +    reg &= ~0x00400000;
3394 +    IFX_REG_W32(reg, IFX_RCU_RST_REQ);
3395 +}
3396 +
3397 +static inline void pcie_phy_rst_assert(int pcie_port)
3398 +{
3399 +    u32 reg;
3400 +
3401 +    reg = IFX_REG_R32(IFX_RCU_RST_REQ);
3402 +    reg |= 0x00001000; /* Bit 12 */
3403 +    IFX_REG_W32(reg, IFX_RCU_RST_REQ);
3404 +}
3405 +
3406 +static inline void pcie_phy_rst_deassert(int pcie_port)
3407 +{
3408 +    u32 reg;
3409 +
3410 +    /* Make sure one micro-second delay */
3411 +    udelay(1);
3412 +
3413 +    reg = IFX_REG_R32(IFX_RCU_RST_REQ);
3414 +    reg &= ~0x00001000; /* Bit 12 */
3415 +    IFX_REG_W32(reg, IFX_RCU_RST_REQ);
3416 +}
3417 +
3418 +static inline void pcie_device_rst_assert(int pcie_port)
3419 +{
3420 +       gpio_set_value(IFX_PCIE_GPIO_RESET, 0);
3421 +  //  ifx_gpio_output_clear(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
3422 +}
3423 +
3424 +static inline void pcie_device_rst_deassert(int pcie_port)
3425 +{
3426 +    mdelay(100);
3427 +       gpio_set_value(IFX_PCIE_GPIO_RESET, 1);
3428 +//    ifx_gpio_output_set(IFX_PCIE_GPIO_RESET, ifx_pcie_gpio_module_id);
3429 +}
3430 +
3431 +static inline void pcie_core_pmu_setup(int pcie_port)
3432 +{
3433 +       struct clk *clk;
3434 +       clk = clk_get_sys("ltq_pcie", "ctl");
3435 +       clk_enable(clk);
3436 +       clk = clk_get_sys("ltq_pcie", "bus");
3437 +       clk_enable(clk);
3438 +
3439 +       //ltq_pmu1_enable(1 << IFX_PMU1_MODULE_PCIE_CTRL);
3440 +       //ltq_pmu_enable(1 << IFX_PMU_MODULE_PCIE_L0_CLK);
3441 +}
3442 +
3443 +static inline void pcie_msi_init(int pcie_port)
3444 +{
3445 +       struct clk *clk;
3446 +    pcie_msi_pic_init(pcie_port);
3447 +       clk = clk_get_sys("ltq_pcie", "msi");
3448 +       clk_enable(clk);
3449 +       //ltq_pmu1_enable(1 << IFX_PMU1_MODULE_MSI);
3450 +}
3451 +
3452 +static inline u32
3453 +ifx_pcie_bus_nr_deduct(u32 bus_number, int pcie_port)
3454 +{
3455 +    u32 tbus_number = bus_number;
3456 +
3457 +#ifdef CONFIG_IFX_PCI
3458 +    if (pcibios_host_nr() > 1) {
3459 +        tbus_number -= pcibios_1st_host_bus_nr();
3460 +    }
3461 +#endif /* CONFIG_IFX_PCI */
3462 +    return tbus_number;
3463 +}
3464 +
3465 +static inline u32
3466 +ifx_pcie_bus_enum_hack(struct pci_bus *bus, u32 devfn, int where, u32 value, int pcie_port, int read)
3467 +{
3468 +    struct pci_dev *pdev;
3469 +    u32 tvalue = value;
3470 +
3471 +    /* Sanity check */
3472 +    pdev = pci_get_slot(bus, devfn);
3473 +    if (pdev == NULL) {
3474 +        return tvalue;
3475 +    }
3476 +
3477 +    /* Only care about PCI bridge */
3478 +    if (pdev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
3479 +        return tvalue;
3480 +    }
3481 +
3482 +    if (read) { /* Read hack */
3483 +    #ifdef CONFIG_IFX_PCI
3484 +        if (pcibios_host_nr() > 1) {
3485 +            tvalue = ifx_pcie_bus_enum_read_hack(where, tvalue);
3486 +        }
3487 +    #endif /* CONFIG_IFX_PCI */
3488 +    }
3489 +    else { /* Write hack */
3490 +    #ifdef CONFIG_IFX_PCI
3491 +        if (pcibios_host_nr() > 1) {
3492 +            tvalue = ifx_pcie_bus_enum_write_hack(where, tvalue);
3493 +        }
3494 +    #endif
3495 +    }
3496 +    return tvalue;
3497 +}
3498 +
3499 +#endif /* IFXMIPS_PCIE_VR9_H */
3500 +
3501 --
3502 1.7.7.1
3503