drivers/pci/host/pcie-rockchip.c

   1 /*
   2  * Rockchip AXI PCIe host controller driver
   3  *
   4  * Copyright (c) 2016 Rockchip, Inc.
   5  *
   6  * Author: Shawn Lin <shawn.lin@rock-chips.com>
   7  *         Wenrui Li <wenrui.li@rock-chips.com>
   8  *
   9  * Bits taken from Synopsys Designware Host controller driver and
  10  * ARM PCI Host generic driver.
  11  *
  12  * This program is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation, either version 2 of the License, or
  15  * (at your option) any later version.
  16  */
  17
  18 #include <linux/clk.h>
  19 #include <linux/delay.h>
  20 #include <linux/gpio/consumer.h>
  21 #include <linux/init.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/iopoll.h>
  24 #include <linux/irq.h>
  25 #include <linux/irqchip/chained_irq.h>
  26 #include <linux/irqdomain.h>
  27 #include <linux/kernel.h>
  28 #include <linux/mfd/syscon.h>
  29 #include <linux/of_address.h>
  30 #include <linux/of_device.h>
  31 #include <linux/of_pci.h>
  32 #include <linux/of_platform.h>
  33 #include <linux/of_irq.h>
  34 #include <linux/pci.h>
  35 #include <linux/pci_ids.h>
  36 #include <linux/phy/phy.h>
  37 #include <linux/platform_device.h>
  38 #include <linux/reset.h>
  39 #include <linux/regmap.h>
  40
  41 /*
  42  * The upper 16 bits of PCIE_CLIENT_CONFIG are a write mask for the lower 16
  43  * bits.  This allows atomic updates of the register without locking.
  44  */
  45 #define HIWORD_UPDATE(mask, val)        (((mask) << 16) | (val))
  46 #define HIWORD_UPDATE_BIT(val)          HIWORD_UPDATE(val, val)
  47
  48 #define ENCODE_LANES(x)                 ((((x) >> 1) & 3) << 4)
  49
  50 #define PCIE_CLIENT_BASE                0x0
  51 #define PCIE_CLIENT_CONFIG              (PCIE_CLIENT_BASE + 0x00)
  52 #define   PCIE_CLIENT_CONF_ENABLE         HIWORD_UPDATE_BIT(0x0001)
  53 #define   PCIE_CLIENT_LINK_TRAIN_ENABLE   HIWORD_UPDATE_BIT(0x0002)
  54 #define   PCIE_CLIENT_ARI_ENABLE          HIWORD_UPDATE_BIT(0x0008)
  55 #define   PCIE_CLIENT_CONF_LANE_NUM(x)    HIWORD_UPDATE(0x0030, ENCODE_LANES(x))
  56 #define   PCIE_CLIENT_MODE_RC             HIWORD_UPDATE_BIT(0x0040)
  57 #define   PCIE_CLIENT_GEN_SEL_1           HIWORD_UPDATE(0x0080, 0)
  58 #define   PCIE_CLIENT_GEN_SEL_2           HIWORD_UPDATE_BIT(0x0080)
  59 #define PCIE_CLIENT_DEBUG_OUT_0         (PCIE_CLIENT_BASE + 0x3c)
  60 #define   PCIE_CLIENT_DEBUG_LTSSM_MASK          GENMASK(5, 0)
  61 #define   PCIE_CLIENT_DEBUG_LTSSM_L1            0x18
  62 #define   PCIE_CLIENT_DEBUG_LTSSM_L2            0x19
  63 #define PCIE_CLIENT_BASIC_STATUS1       (PCIE_CLIENT_BASE + 0x48)
  64 #define   PCIE_CLIENT_LINK_STATUS_UP            0x00300000
  65 #define   PCIE_CLIENT_LINK_STATUS_MASK          0x00300000
  66 #define PCIE_CLIENT_INT_MASK            (PCIE_CLIENT_BASE + 0x4c)
  67 #define PCIE_CLIENT_INT_STATUS          (PCIE_CLIENT_BASE + 0x50)
  68 #define   PCIE_CLIENT_INTR_MASK                 GENMASK(8, 5)
  69 #define   PCIE_CLIENT_INTR_SHIFT                5
  70 #define   PCIE_CLIENT_INT_LEGACY_DONE           BIT(15)
  71 #define   PCIE_CLIENT_INT_MSG                   BIT(14)
  72 #define   PCIE_CLIENT_INT_HOT_RST               BIT(13)
  73 #define   PCIE_CLIENT_INT_DPA                   BIT(12)
  74 #define   PCIE_CLIENT_INT_FATAL_ERR             BIT(11)
  75 #define   PCIE_CLIENT_INT_NFATAL_ERR            BIT(10)
  76 #define   PCIE_CLIENT_INT_CORR_ERR              BIT(9)
  77 #define   PCIE_CLIENT_INT_INTD                  BIT(8)
  78 #define   PCIE_CLIENT_INT_INTC                  BIT(7)
  79 #define   PCIE_CLIENT_INT_INTB                  BIT(6)
  80 #define   PCIE_CLIENT_INT_INTA                  BIT(5)
  81 #define   PCIE_CLIENT_INT_LOCAL                 BIT(4)
  82 #define   PCIE_CLIENT_INT_UDMA                  BIT(3)
  83 #define   PCIE_CLIENT_INT_PHY                   BIT(2)
  84 #define   PCIE_CLIENT_INT_HOT_PLUG              BIT(1)
  85 #define   PCIE_CLIENT_INT_PWR_STCG              BIT(0)
  86
  87 #define PCIE_CLIENT_INT_LEGACY \
  88         (PCIE_CLIENT_INT_INTA | PCIE_CLIENT_INT_INTB | \
  89         PCIE_CLIENT_INT_INTC | PCIE_CLIENT_INT_INTD)
  90
  91 #define PCIE_CLIENT_INT_CLI \
  92         (PCIE_CLIENT_INT_CORR_ERR | PCIE_CLIENT_INT_NFATAL_ERR | \
  93         PCIE_CLIENT_INT_FATAL_ERR | PCIE_CLIENT_INT_DPA | \
  94         PCIE_CLIENT_INT_HOT_RST | PCIE_CLIENT_INT_MSG | \
  95         PCIE_CLIENT_INT_LEGACY_DONE | PCIE_CLIENT_INT_LEGACY | \
  96         PCIE_CLIENT_INT_PHY)
  97
  98 #define PCIE_CORE_CTRL_MGMT_BASE        0x900000
  99 #define PCIE_CORE_CTRL                  (PCIE_CORE_CTRL_MGMT_BASE + 0x000)
 100 #define   PCIE_CORE_PL_CONF_SPEED_5G            0x00000008
 101 #define   PCIE_CORE_PL_CONF_SPEED_MASK          0x00000018
 102 #define   PCIE_CORE_PL_CONF_LANE_MASK           0x00000006
 103 #define   PCIE_CORE_PL_CONF_LANE_SHIFT          1
 104 #define PCIE_CORE_CTRL_PLC1             (PCIE_CORE_CTRL_MGMT_BASE + 0x004)
 105 #define   PCIE_CORE_CTRL_PLC1_FTS_MASK          GENMASK(23, 8)
 106 #define   PCIE_CORE_CTRL_PLC1_FTS_SHIFT         8
 107 #define   PCIE_CORE_CTRL_PLC1_FTS_CNT           0xffff
 108 #define PCIE_CORE_TXCREDIT_CFG1         (PCIE_CORE_CTRL_MGMT_BASE + 0x020)
 109 #define   PCIE_CORE_TXCREDIT_CFG1_MUI_MASK      0xFFFF0000
 110 #define   PCIE_CORE_TXCREDIT_CFG1_MUI_SHIFT     16
 111 #define   PCIE_CORE_TXCREDIT_CFG1_MUI_ENCODE(x) \
 112                 (((x) >> 3) << PCIE_CORE_TXCREDIT_CFG1_MUI_SHIFT)
 113 #define PCIE_CORE_INT_STATUS            (PCIE_CORE_CTRL_MGMT_BASE + 0x20c)
 114 #define   PCIE_CORE_INT_PRFPE                   BIT(0)
 115 #define   PCIE_CORE_INT_CRFPE                   BIT(1)
 116 #define   PCIE_CORE_INT_RRPE                    BIT(2)
 117 #define   PCIE_CORE_INT_PRFO                    BIT(3)
 118 #define   PCIE_CORE_INT_CRFO                    BIT(4)
 119 #define   PCIE_CORE_INT_RT                      BIT(5)
 120 #define   PCIE_CORE_INT_RTR                     BIT(6)
 121 #define   PCIE_CORE_INT_PE                      BIT(7)
 122 #define   PCIE_CORE_INT_MTR                     BIT(8)
 123 #define   PCIE_CORE_INT_UCR                     BIT(9)
 124 #define   PCIE_CORE_INT_FCE                     BIT(10)
 125 #define   PCIE_CORE_INT_CT                      BIT(11)
 126 #define   PCIE_CORE_INT_UTC                     BIT(18)
 127 #define   PCIE_CORE_INT_MMVC                    BIT(19)
 128 #define PCIE_CORE_INT_MASK              (PCIE_CORE_CTRL_MGMT_BASE + 0x210)
 129 #define PCIE_RC_BAR_CONF                (PCIE_CORE_CTRL_MGMT_BASE + 0x300)
 130
 131 #define PCIE_CORE_INT \
 132                 (PCIE_CORE_INT_PRFPE | PCIE_CORE_INT_CRFPE | \
 133                  PCIE_CORE_INT_RRPE | PCIE_CORE_INT_CRFO | \
 134                  PCIE_CORE_INT_RT | PCIE_CORE_INT_RTR | \
 135                  PCIE_CORE_INT_PE | PCIE_CORE_INT_MTR | \
 136                  PCIE_CORE_INT_UCR | PCIE_CORE_INT_FCE | \
 137                  PCIE_CORE_INT_CT | PCIE_CORE_INT_UTC | \
 138                  PCIE_CORE_INT_MMVC)
 139
 140 #define PCIE_RC_CONFIG_BASE             0xa00000
 141 #define PCIE_RC_CONFIG_VENDOR           (PCIE_RC_CONFIG_BASE + 0x00)
 142 #define PCIE_RC_CONFIG_RID_CCR          (PCIE_RC_CONFIG_BASE + 0x08)
 143 #define   PCIE_RC_CONFIG_SCC_SHIFT              16
 144 #define PCIE_RC_CONFIG_DCR              (PCIE_RC_CONFIG_BASE + 0xc4)
 145 #define   PCIE_RC_CONFIG_DCR_CSPL_SHIFT         18
 146 #define   PCIE_RC_CONFIG_DCR_CSPL_LIMIT         0xff
 147 #define   PCIE_RC_CONFIG_DCR_CPLS_SHIFT         26
 148 #define PCIE_RC_CONFIG_LCS              (PCIE_RC_CONFIG_BASE + 0xd0)
 149 #define PCIE_RC_CONFIG_L1_SUBSTATE_CTRL2 (PCIE_RC_CONFIG_BASE + 0x90c)
 150 #define PCIE_RC_CONFIG_THP_CAP          (PCIE_RC_CONFIG_BASE + 0x274)
 151 #define   PCIE_RC_CONFIG_THP_CAP_NEXT_MASK      GENMASK(31, 20)
 152
 153 #define PCIE_CORE_AXI_CONF_BASE         0xc00000
 154 #define PCIE_CORE_OB_REGION_ADDR0       (PCIE_CORE_AXI_CONF_BASE + 0x0)
 155 #define   PCIE_CORE_OB_REGION_ADDR0_NUM_BITS    0x3f
 156 #define   PCIE_CORE_OB_REGION_ADDR0_LO_ADDR     0xffffff00
 157 #define PCIE_CORE_OB_REGION_ADDR1       (PCIE_CORE_AXI_CONF_BASE + 0x4)
 158 #define PCIE_CORE_OB_REGION_DESC0       (PCIE_CORE_AXI_CONF_BASE + 0x8)
 159 #define PCIE_CORE_OB_REGION_DESC1       (PCIE_CORE_AXI_CONF_BASE + 0xc)
 160
 161 #define PCIE_CORE_AXI_INBOUND_BASE      0xc00800
 162 #define PCIE_RP_IB_ADDR0                (PCIE_CORE_AXI_INBOUND_BASE + 0x0)
 163 #define   PCIE_CORE_IB_REGION_ADDR0_NUM_BITS    0x3f
 164 #define   PCIE_CORE_IB_REGION_ADDR0_LO_ADDR     0xffffff00
 165 #define PCIE_RP_IB_ADDR1                (PCIE_CORE_AXI_INBOUND_BASE + 0x4)
 166
 167 /* Size of one AXI Region (not Region 0) */
 168 #define AXI_REGION_SIZE                         BIT(20)
 169 /* Size of Region 0, equal to sum of sizes of other regions */
 170 #define AXI_REGION_0_SIZE                       (32 * (0x1 << 20))
 171 #define OB_REG_SIZE_SHIFT                       5
 172 #define IB_ROOT_PORT_REG_SIZE_SHIFT             3
 173 #define AXI_WRAPPER_IO_WRITE                    0x6
 174 #define AXI_WRAPPER_MEM_WRITE                   0x2
 175 #define AXI_WRAPPER_NOR_MSG                     0xc
 176
 177 #define MAX_AXI_IB_ROOTPORT_REGION_NUM          3
 178 #define MIN_AXI_ADDR_BITS_PASSED                8
 179 #define PCIE_RC_SEND_PME_OFF                    0x11960
 180 #define ROCKCHIP_VENDOR_ID                      0x1d87
 181 #define PCIE_ECAM_BUS(x)                        (((x) & 0xff) << 20)
 182 #define PCIE_ECAM_DEV(x)                        (((x) & 0x1f) << 15)
 183 #define PCIE_ECAM_FUNC(x)                       (((x) & 0x7) << 12)
 184 #define PCIE_ECAM_REG(x)                        (((x) & 0xfff) << 0)
 185 #define PCIE_ECAM_ADDR(bus, dev, func, reg) \
 186           (PCIE_ECAM_BUS(bus) | PCIE_ECAM_DEV(dev) | \
 187            PCIE_ECAM_FUNC(func) | PCIE_ECAM_REG(reg))
 188 #define PCIE_LINK_IS_L2(x) \
 189                 (((x) & PCIE_CLIENT_DEBUG_LTSSM_MASK) == \
 190                  PCIE_CLIENT_DEBUG_LTSSM_L2)
 191
 192 #define RC_REGION_0_ADDR_TRANS_H                0x00000000
 193 #define RC_REGION_0_ADDR_TRANS_L                0x00000000
 194 #define RC_REGION_0_PASS_BITS                   (25 - 1)
 195 #define MAX_AXI_WRAPPER_REGION_NUM              33
 196
 197 struct rockchip_pcie {
 198         void    __iomem *reg_base;              /* DT axi-base */
 199         void    __iomem *apb_base;              /* DT apb-base */
 200         struct  phy *phy;
 201         struct  reset_control *core_rst;
 202         struct  reset_control *mgmt_rst;
 203         struct  reset_control *mgmt_sticky_rst;
 204         struct  reset_control *pipe_rst;
 205         struct  reset_control *pm_rst;
 206         struct  reset_control *aclk_rst;
 207         struct  reset_control *pclk_rst;
 208         struct  clk *aclk_pcie;
 209         struct  clk *aclk_perf_pcie;
 210         struct  clk *hclk_pcie;
 211         struct  clk *clk_pcie_pm;
 212         struct  regulator *vpcie3v3; /* 3.3V power supply */
 213         struct  regulator *vpcie1v8; /* 1.8V power supply */
 214         struct  regulator *vpcie0v9; /* 0.9V power supply */
 215         struct  gpio_desc *ep_gpio;
 216         u32     lanes;
 217         u8      root_bus_nr;
 218         int     link_gen;
 219         struct  device *dev;
 220         struct  irq_domain *irq_domain;
 221         u32     io_size;
 222         int     offset;
 223         phys_addr_t io_bus_addr;
 224         void    __iomem *msg_region;
 225         u32     mem_size;
 226         phys_addr_t msg_bus_addr;
 227         phys_addr_t mem_bus_addr;
 228 };
 229
 230 static u32 rockchip_pcie_read(struct rockchip_pcie *rockchip, u32 reg)
 231 {
 232         return readl(rockchip->apb_base + reg);
 233 }
 234
 235 static void rockchip_pcie_write(struct rockchip_pcie *rockchip, u32 val,
 236                                 u32 reg)
 237 {
 238         writel(val, rockchip->apb_base + reg);
 239 }
 240
 241 static void rockchip_pcie_enable_bw_int(struct rockchip_pcie *rockchip)
 242 {
 243         u32 status;
 244
 245         status = rockchip_pcie_read(rockchip, PCIE_RC_CONFIG_LCS);
 246         status |= (PCI_EXP_LNKCTL_LBMIE | PCI_EXP_LNKCTL_LABIE);
 247         rockchip_pcie_write(rockchip, status, PCIE_RC_CONFIG_LCS);
 248 }
 249
 250 static void rockchip_pcie_clr_bw_int(struct rockchip_pcie *rockchip)
 251 {
 252         u32 status;
 253
 254         status = rockchip_pcie_read(rockchip, PCIE_RC_CONFIG_LCS);
 255         status |= (PCI_EXP_LNKSTA_LBMS | PCI_EXP_LNKSTA_LABS) << 16;
 256         rockchip_pcie_write(rockchip, status, PCIE_RC_CONFIG_LCS);
 257 }
 258
 259 static void rockchip_pcie_update_txcredit_mui(struct rockchip_pcie *rockchip)
 260 {
 261         u32 val;
 262
 263         /* Update Tx credit maximum update interval */
 264         val = rockchip_pcie_read(rockchip, PCIE_CORE_TXCREDIT_CFG1);
 265         val &= ~PCIE_CORE_TXCREDIT_CFG1_MUI_MASK;
 266         val |= PCIE_CORE_TXCREDIT_CFG1_MUI_ENCODE(24000);       /* ns */
 267         rockchip_pcie_write(rockchip, val, PCIE_CORE_TXCREDIT_CFG1);
 268 }
 269
 270 static int rockchip_pcie_valid_device(struct rockchip_pcie *rockchip,
 271                                       struct pci_bus *bus, int dev)
 272 {
 273         /* access only one slot on each root port */
 274         if (bus->number == rockchip->root_bus_nr && dev > 0)
 275                 return 0;
 276
 277         /*
 278          * do not read more than one device on the bus directly attached
 279          * to RC's downstream side.
 280          */
 281         if (bus->primary == rockchip->root_bus_nr && dev > 0)
 282                 return 0;
 283
 284         return 1;
 285 }
 286
 287 static int rockchip_pcie_rd_own_conf(struct rockchip_pcie *rockchip,
 288                                      int where, int size, u32 *val)
 289 {
 290         void __iomem *addr = rockchip->apb_base + PCIE_RC_CONFIG_BASE + where;
 291
 292         if (!IS_ALIGNED((uintptr_t)addr, size)) {
 293                 *val = 0;
 294                 return PCIBIOS_BAD_REGISTER_NUMBER;
 295         }
 296
 297         if (size == 4) {
 298                 *val = readl(addr);
 299         } else if (size == 2) {
 300                 *val = readw(addr);
 301         } else if (size == 1) {
 302                 *val = readb(addr);
 303         } else {
 304                 *val = 0;
 305                 return PCIBIOS_BAD_REGISTER_NUMBER;
 306         }
 307         return PCIBIOS_SUCCESSFUL;
 308 }
 309
 310 static int rockchip_pcie_wr_own_conf(struct rockchip_pcie *rockchip,
 311                                      int where, int size, u32 val)
 312 {
 313         u32 mask, tmp, offset;
 314
 315         offset = where & ~0x3;
 316
 317         if (size == 4) {
 318                 writel(val, rockchip->apb_base + PCIE_RC_CONFIG_BASE + offset);
 319                 return PCIBIOS_SUCCESSFUL;
 320         }
 321
 322         mask = ~(((1 << (size * 8)) - 1) << ((where & 0x3) * 8));
 323
 324         /*
 325          * N.B. This read/modify/write isn't safe in general because it can
 326          * corrupt RW1C bits in adjacent registers.  But the hardware
 327          * doesn't support smaller writes.
 328          */
 329         tmp = readl(rockchip->apb_base + PCIE_RC_CONFIG_BASE + offset) & mask;
 330         tmp |= val << ((where & 0x3) * 8);
 331         writel(tmp, rockchip->apb_base + PCIE_RC_CONFIG_BASE + offset);
 332
 333         return PCIBIOS_SUCCESSFUL;
 334 }
 335
 336 static int rockchip_pcie_rd_other_conf(struct rockchip_pcie *rockchip,
 337                                        struct pci_bus *bus, u32 devfn,
 338                                        int where, int size, u32 *val)
 339 {
 340         u32 busdev;
 341
 342         busdev = PCIE_ECAM_ADDR(bus->number, PCI_SLOT(devfn),
 343                                 PCI_FUNC(devfn), where);
 344
 345         if (!IS_ALIGNED(busdev, size)) {
 346                 *val = 0;
 347                 return PCIBIOS_BAD_REGISTER_NUMBER;
 348         }
 349
 350         if (size == 4) {
 351                 *val = readl(rockchip->reg_base + busdev);
 352         } else if (size == 2) {
 353                 *val = readw(rockchip->reg_base + busdev);
 354         } else if (size == 1) {
 355                 *val = readb(rockchip->reg_base + busdev);
 356         } else {
 357                 *val = 0;
 358                 return PCIBIOS_BAD_REGISTER_NUMBER;
 359         }
 360         return PCIBIOS_SUCCESSFUL;
 361 }
 362
 363 static int rockchip_pcie_wr_other_conf(struct rockchip_pcie *rockchip,
 364                                        struct pci_bus *bus, u32 devfn,
 365                                        int where, int size, u32 val)
 366 {
 367         u32 busdev;
 368
 369         busdev = PCIE_ECAM_ADDR(bus->number, PCI_SLOT(devfn),
 370                                 PCI_FUNC(devfn), where);
 371         if (!IS_ALIGNED(busdev, size))
 372                 return PCIBIOS_BAD_REGISTER_NUMBER;
 373
 374         if (size == 4)
 375                 writel(val, rockchip->reg_base + busdev);
 376         else if (size == 2)
 377                 writew(val, rockchip->reg_base + busdev);
 378         else if (size == 1)
 379                 writeb(val, rockchip->reg_base + busdev);
 380         else
 381                 return PCIBIOS_BAD_REGISTER_NUMBER;
 382
 383         return PCIBIOS_SUCCESSFUL;
 384 }
 385
 386 static int rockchip_pcie_rd_conf(struct pci_bus *bus, u32 devfn, int where,
 387                                  int size, u32 *val)
 388 {
 389         struct rockchip_pcie *rockchip = bus->sysdata;
 390
 391         if (!rockchip_pcie_valid_device(rockchip, bus, PCI_SLOT(devfn))) {
 392                 *val = 0xffffffff;
 393                 return PCIBIOS_DEVICE_NOT_FOUND;
 394         }
 395
 396         if (bus->number == rockchip->root_bus_nr)
 397                 return rockchip_pcie_rd_own_conf(rockchip, where, size, val);
 398
 399         return rockchip_pcie_rd_other_conf(rockchip, bus, devfn, where, size, val);
 400 }
 401
 402 static int rockchip_pcie_wr_conf(struct pci_bus *bus, u32 devfn,
 403                                  int where, int size, u32 val)
 404 {
 405         struct rockchip_pcie *rockchip = bus->sysdata;
 406
 407         if (!rockchip_pcie_valid_device(rockchip, bus, PCI_SLOT(devfn)))
 408                 return PCIBIOS_DEVICE_NOT_FOUND;
 409
 410         if (bus->number == rockchip->root_bus_nr)
 411                 return rockchip_pcie_wr_own_conf(rockchip, where, size, val);
 412
 413         return rockchip_pcie_wr_other_conf(rockchip, bus, devfn, where, size, val);
 414 }
 415
 416 static struct pci_ops rockchip_pcie_ops = {
 417         .read = rockchip_pcie_rd_conf,
 418         .write = rockchip_pcie_wr_conf,
 419 };
 420
 421 static void rockchip_pcie_set_power_limit(struct rockchip_pcie *rockchip)
 422 {
 423         u32 status, curr, scale, power;
 424
 425         if (IS_ERR(rockchip->vpcie3v3))
 426                 return;
 427
 428         /*
 429          * Set RC's captured slot power limit and scale if
 430          * vpcie3v3 available. The default values are both zero
 431          * which means the software should set these two according
 432          * to the actual power supply.
 433          */
 434         curr = regulator_get_current_limit(rockchip->vpcie3v3);
 435         if (curr > 0) {
 436                 scale = 3; /* 0.001x */
 437                 curr = curr / 1000; /* convert to mA */
 438                 power = (curr * 3300) / 1000; /* milliwatt */
 439                 while (power > PCIE_RC_CONFIG_DCR_CSPL_LIMIT) {
 440                         if (!scale) {
 441                                 dev_warn(rockchip->dev, "invalid power supply\n");
 442                                 return;
 443                         }
 444                         scale--;
 445                         power = power / 10;
 446                 }
 447
 448                 status = rockchip_pcie_read(rockchip, PCIE_RC_CONFIG_DCR);
 449                 status |= (power << PCIE_RC_CONFIG_DCR_CSPL_SHIFT) |
 450                           (scale << PCIE_RC_CONFIG_DCR_CPLS_SHIFT);
 451                 rockchip_pcie_write(rockchip, status, PCIE_RC_CONFIG_DCR);
 452         }
 453 }
 454
 455 /**
 456  * rockchip_pcie_init_port - Initialize hardware
 457  * @rockchip: PCIe port information
 458  */
 459 static int rockchip_pcie_init_port(struct rockchip_pcie *rockchip)
 460 {
 461         struct device *dev = rockchip->dev;
 462         int err;
 463         u32 status;
 464         unsigned long timeout;
 465
 466         gpiod_set_value(rockchip->ep_gpio, 0);
 467
 468         err = reset_control_assert(rockchip->aclk_rst);
 469         if (err) {
 470                 dev_err(dev, "assert aclk_rst err %d\n", err);
 471                 return err;
 472         }
 473
 474         err = reset_control_assert(rockchip->pclk_rst);
 475         if (err) {
 476                 dev_err(dev, "assert pclk_rst err %d\n", err);
 477                 return err;
 478         }
 479
 480         err = reset_control_assert(rockchip->pm_rst);
 481         if (err) {
 482                 dev_err(dev, "assert pm_rst err %d\n", err);
 483                 return err;
 484         }
 485
 486         err = phy_init(rockchip->phy);
 487         if (err < 0) {
 488                 dev_err(dev, "fail to init phy, err %d\n", err);
 489                 return err;
 490         }
 491
 492         err = reset_control_assert(rockchip->core_rst);
 493         if (err) {
 494                 dev_err(dev, "assert core_rst err %d\n", err);
 495                 return err;
 496         }
 497
 498         err = reset_control_assert(rockchip->mgmt_rst);
 499         if (err) {
 500                 dev_err(dev, "assert mgmt_rst err %d\n", err);
 501                 return err;
 502         }
 503
 504         err = reset_control_assert(rockchip->mgmt_sticky_rst);
 505         if (err) {
 506                 dev_err(dev, "assert mgmt_sticky_rst err %d\n", err);
 507                 return err;
 508         }
 509
 510         err = reset_control_assert(rockchip->pipe_rst);
 511         if (err) {
 512                 dev_err(dev, "assert pipe_rst err %d\n", err);
 513                 return err;
 514         }
 515
 516         udelay(10);
 517
 518         err = reset_control_deassert(rockchip->pm_rst);
 519         if (err) {
 520                 dev_err(dev, "deassert pm_rst err %d\n", err);
 521                 return err;
 522         }
 523
 524         err = reset_control_deassert(rockchip->aclk_rst);
 525         if (err) {
 526                 dev_err(dev, "deassert aclk_rst err %d\n", err);
 527                 return err;
 528         }
 529
 530         err = reset_control_deassert(rockchip->pclk_rst);
 531         if (err) {
 532                 dev_err(dev, "deassert pclk_rst err %d\n", err);
 533                 return err;
 534         }
 535
 536         if (rockchip->link_gen == 2)
 537                 rockchip_pcie_write(rockchip, PCIE_CLIENT_GEN_SEL_2,
 538                                     PCIE_CLIENT_CONFIG);
 539         else
 540                 rockchip_pcie_write(rockchip, PCIE_CLIENT_GEN_SEL_1,
 541                                     PCIE_CLIENT_CONFIG);
 542
 543         rockchip_pcie_write(rockchip,
 544                             PCIE_CLIENT_CONF_ENABLE |
 545                             PCIE_CLIENT_LINK_TRAIN_ENABLE |
 546                             PCIE_CLIENT_ARI_ENABLE |
 547                             PCIE_CLIENT_CONF_LANE_NUM(rockchip->lanes) |
 548                             PCIE_CLIENT_MODE_RC,
 549                             PCIE_CLIENT_CONFIG);
 550
 551         err = phy_power_on(rockchip->phy);
 552         if (err) {
 553                 dev_err(dev, "fail to power on phy, err %d\n", err);
 554                 return err;
 555         }
 556
 557         /*
 558          * Please don't reorder the deassert sequence of the following
 559          * four reset pins.
 560          */
 561         err = reset_control_deassert(rockchip->mgmt_sticky_rst);
 562         if (err) {
 563                 dev_err(dev, "deassert mgmt_sticky_rst err %d\n", err);
 564                 return err;
 565         }
 566
 567         err = reset_control_deassert(rockchip->core_rst);
 568         if (err) {
 569                 dev_err(dev, "deassert core_rst err %d\n", err);
 570                 return err;
 571         }
 572
 573         err = reset_control_deassert(rockchip->mgmt_rst);
 574         if (err) {
 575                 dev_err(dev, "deassert mgmt_rst err %d\n", err);
 576                 return err;
 577         }
 578
 579         err = reset_control_deassert(rockchip->pipe_rst);
 580         if (err) {
 581                 dev_err(dev, "deassert pipe_rst err %d\n", err);
 582                 return err;
 583         }
 584
 585         /* Fix the transmitted FTS count desired to exit from L0s. */
 586         status = rockchip_pcie_read(rockchip, PCIE_CORE_CTRL_PLC1);
 587         status = (status & ~PCIE_CORE_CTRL_PLC1_FTS_MASK) |
 588                  (PCIE_CORE_CTRL_PLC1_FTS_CNT << PCIE_CORE_CTRL_PLC1_FTS_SHIFT);
 589         rockchip_pcie_write(rockchip, status, PCIE_CORE_CTRL_PLC1);
 590
 591         rockchip_pcie_set_power_limit(rockchip);
 592
 593         /* Set RC's clock architecture as common clock */
 594         status = rockchip_pcie_read(rockchip, PCIE_RC_CONFIG_LCS);
 595         status |= PCI_EXP_LNKCTL_CCC;
 596         rockchip_pcie_write(rockchip, status, PCIE_RC_CONFIG_LCS);
 597
 598         /* Enable Gen1 training */
 599         rockchip_pcie_write(rockchip, PCIE_CLIENT_LINK_TRAIN_ENABLE,
 600                             PCIE_CLIENT_CONFIG);
 601
 602         gpiod_set_value(rockchip->ep_gpio, 1);
 603
 604         /* 500ms timeout value should be enough for Gen1/2 training */
 605         timeout = jiffies + msecs_to_jiffies(500);
 606
 607         for (;;) {
 608                 status = rockchip_pcie_read(rockchip,
 609                                             PCIE_CLIENT_BASIC_STATUS1);
 610                 if ((status & PCIE_CLIENT_LINK_STATUS_MASK) ==
 611                     PCIE_CLIENT_LINK_STATUS_UP) {
 612                         dev_dbg(dev, "PCIe link training gen1 pass!\n");
 613                         break;
 614                 }
 615
 616                 if (time_after(jiffies, timeout)) {
 617                         dev_err(dev, "PCIe link training gen1 timeout!\n");
 618                         return -ETIMEDOUT;
 619                 }
 620
 621                 msleep(20);
 622         }
 623
 624         if (rockchip->link_gen == 2) {
 625                 /*
 626                  * Enable retrain for gen2. This should be configured only after
 627                  * gen1 finished.
 628                  */
 629                 status = rockchip_pcie_read(rockchip, PCIE_RC_CONFIG_LCS);
 630                 status |= PCI_EXP_LNKCTL_RL;
 631                 rockchip_pcie_write(rockchip, status, PCIE_RC_CONFIG_LCS);
 632
 633                 timeout = jiffies + msecs_to_jiffies(500);
 634                 for (;;) {
 635                         status = rockchip_pcie_read(rockchip, PCIE_CORE_CTRL);
 636                         if ((status & PCIE_CORE_PL_CONF_SPEED_MASK) ==
 637                             PCIE_CORE_PL_CONF_SPEED_5G) {
 638                                 dev_dbg(dev, "PCIe link training gen2 pass!\n");
 639                                 break;
 640                         }
 641
 642                         if (time_after(jiffies, timeout)) {
 643                                 dev_dbg(dev, "PCIe link training gen2 timeout, fall back to gen1!\n");
 644                                 break;
 645                         }
 646
 647                         msleep(20);
 648                 }
 649         }
 650
 651         /* Check the final link width from negotiated lane counter from MGMT */
 652         status = rockchip_pcie_read(rockchip, PCIE_CORE_CTRL);
 653         status = 0x1 << ((status & PCIE_CORE_PL_CONF_LANE_MASK) >>
 654                           PCIE_CORE_PL_CONF_LANE_SHIFT);
 655         dev_dbg(dev, "current link width is x%d\n", status);
 656
 657         rockchip_pcie_write(rockchip, ROCKCHIP_VENDOR_ID,
 658                             PCIE_RC_CONFIG_VENDOR);
 659         rockchip_pcie_write(rockchip,
 660                             PCI_CLASS_BRIDGE_PCI << PCIE_RC_CONFIG_SCC_SHIFT,
 661                             PCIE_RC_CONFIG_RID_CCR);
 662
 663         /* Clear THP cap's next cap pointer to remove L1 substate cap */
 664         status = rockchip_pcie_read(rockchip, PCIE_RC_CONFIG_THP_CAP);
 665         status &= ~PCIE_RC_CONFIG_THP_CAP_NEXT_MASK;
 666         rockchip_pcie_write(rockchip, status, PCIE_RC_CONFIG_THP_CAP);
 667
 668         rockchip_pcie_write(rockchip, 0x0, PCIE_RC_BAR_CONF);
 669
 670         rockchip_pcie_write(rockchip,
 671                             (RC_REGION_0_ADDR_TRANS_L + RC_REGION_0_PASS_BITS),
 672                             PCIE_CORE_OB_REGION_ADDR0);
 673         rockchip_pcie_write(rockchip, RC_REGION_0_ADDR_TRANS_H,
 674                             PCIE_CORE_OB_REGION_ADDR1);
 675         rockchip_pcie_write(rockchip, 0x0080000a, PCIE_CORE_OB_REGION_DESC0);
 676         rockchip_pcie_write(rockchip, 0x0, PCIE_CORE_OB_REGION_DESC1);
 677
 678         return 0;
 679 }
 680
 681 static irqreturn_t rockchip_pcie_subsys_irq_handler(int irq, void *arg)
 682 {
 683         struct rockchip_pcie *rockchip = arg;
 684         struct device *dev = rockchip->dev;
 685         u32 reg;
 686         u32 sub_reg;
 687
 688         reg = rockchip_pcie_read(rockchip, PCIE_CLIENT_INT_STATUS);
 689         if (reg & PCIE_CLIENT_INT_LOCAL) {
 690                 dev_dbg(dev, "local interrupt received\n");
 691                 sub_reg = rockchip_pcie_read(rockchip, PCIE_CORE_INT_STATUS);
 692                 if (sub_reg & PCIE_CORE_INT_PRFPE)
 693                         dev_dbg(dev, "parity error detected while reading from the PNP receive FIFO RAM\n");
 694
 695                 if (sub_reg & PCIE_CORE_INT_CRFPE)
 696                         dev_dbg(dev, "parity error detected while reading from the Completion Receive FIFO RAM\n");
 697
 698                 if (sub_reg & PCIE_CORE_INT_RRPE)
 699                         dev_dbg(dev, "parity error detected while reading from replay buffer RAM\n");
 700
 701                 if (sub_reg & PCIE_CORE_INT_PRFO)
 702                         dev_dbg(dev, "overflow occurred in the PNP receive FIFO\n");
 703
 704                 if (sub_reg & PCIE_CORE_INT_CRFO)
 705                         dev_dbg(dev, "overflow occurred in the completion receive FIFO\n");
 706
 707                 if (sub_reg & PCIE_CORE_INT_RT)
 708                         dev_dbg(dev, "replay timer timed out\n");
 709
 710                 if (sub_reg & PCIE_CORE_INT_RTR)
 711                         dev_dbg(dev, "replay timer rolled over after 4 transmissions of the same TLP\n");
 712
 713                 if (sub_reg & PCIE_CORE_INT_PE)
 714                         dev_dbg(dev, "phy error detected on receive side\n");
 715
 716                 if (sub_reg & PCIE_CORE_INT_MTR)
 717                         dev_dbg(dev, "malformed TLP received from the link\n");
 718
 719                 if (sub_reg & PCIE_CORE_INT_UCR)
 720                         dev_dbg(dev, "malformed TLP received from the link\n");
 721
 722                 if (sub_reg & PCIE_CORE_INT_FCE)
 723                         dev_dbg(dev, "an error was observed in the flow control advertisements from the other side\n");
 724
 725                 if (sub_reg & PCIE_CORE_INT_CT)
 726                         dev_dbg(dev, "a request timed out waiting for completion\n");
 727
 728                 if (sub_reg & PCIE_CORE_INT_UTC)
 729                         dev_dbg(dev, "unmapped TC error\n");
 730
 731                 if (sub_reg & PCIE_CORE_INT_MMVC)
 732                         dev_dbg(dev, "MSI mask register changes\n");
 733
 734                 rockchip_pcie_write(rockchip, sub_reg, PCIE_CORE_INT_STATUS);
 735         } else if (reg & PCIE_CLIENT_INT_PHY) {
 736                 dev_dbg(dev, "phy link changes\n");
 737                 rockchip_pcie_update_txcredit_mui(rockchip);
 738                 rockchip_pcie_clr_bw_int(rockchip);
 739         }
 740
 741         rockchip_pcie_write(rockchip, reg & PCIE_CLIENT_INT_LOCAL,
 742                             PCIE_CLIENT_INT_STATUS);
 743
 744         return IRQ_HANDLED;
 745 }
 746
 747 static irqreturn_t rockchip_pcie_client_irq_handler(int irq, void *arg)
 748 {
 749         struct rockchip_pcie *rockchip = arg;
 750         struct device *dev = rockchip->dev;
 751         u32 reg;
 752
 753         reg = rockchip_pcie_read(rockchip, PCIE_CLIENT_INT_STATUS);
 754         if (reg & PCIE_CLIENT_INT_LEGACY_DONE)
 755                 dev_dbg(dev, "legacy done interrupt received\n");
 756
 757         if (reg & PCIE_CLIENT_INT_MSG)
 758                 dev_dbg(dev, "message done interrupt received\n");
 759
 760         if (reg & PCIE_CLIENT_INT_HOT_RST)
 761                 dev_dbg(dev, "hot reset interrupt received\n");
 762
 763         if (reg & PCIE_CLIENT_INT_DPA)
 764                 dev_dbg(dev, "dpa interrupt received\n");
 765
 766         if (reg & PCIE_CLIENT_INT_FATAL_ERR)
 767                 dev_dbg(dev, "fatal error interrupt received\n");
 768
 769         if (reg & PCIE_CLIENT_INT_NFATAL_ERR)
 770                 dev_dbg(dev, "no fatal error interrupt received\n");
 771
 772         if (reg & PCIE_CLIENT_INT_CORR_ERR)
 773                 dev_dbg(dev, "correctable error interrupt received\n");
 774
 775         if (reg & PCIE_CLIENT_INT_PHY)
 776                 dev_dbg(dev, "phy interrupt received\n");
 777
 778         rockchip_pcie_write(rockchip, reg & (PCIE_CLIENT_INT_LEGACY_DONE |
 779                               PCIE_CLIENT_INT_MSG | PCIE_CLIENT_INT_HOT_RST |
 780                               PCIE_CLIENT_INT_DPA | PCIE_CLIENT_INT_FATAL_ERR |
 781                               PCIE_CLIENT_INT_NFATAL_ERR |
 782                               PCIE_CLIENT_INT_CORR_ERR |
 783                               PCIE_CLIENT_INT_PHY),
 784                    PCIE_CLIENT_INT_STATUS);
 785
 786         return IRQ_HANDLED;
 787 }
 788
 789 static void rockchip_pcie_legacy_int_handler(struct irq_desc *desc)
 790 {
 791         struct irq_chip *chip = irq_desc_get_chip(desc);
 792         struct rockchip_pcie *rockchip = irq_desc_get_handler_data(desc);
 793         struct device *dev = rockchip->dev;
 794         u32 reg;
 795         u32 hwirq;
 796         u32 virq;
 797
 798         chained_irq_enter(chip, desc);
 799
 800         reg = rockchip_pcie_read(rockchip, PCIE_CLIENT_INT_STATUS);
 801         reg = (reg & PCIE_CLIENT_INTR_MASK) >> PCIE_CLIENT_INTR_SHIFT;
 802
 803         while (reg) {
 804                 hwirq = ffs(reg) - 1;
 805                 reg &= ~BIT(hwirq);
 806
 807                 virq = irq_find_mapping(rockchip->irq_domain, hwirq);
 808                 if (virq)
 809                         generic_handle_irq(virq);
 810                 else
 811                         dev_err(dev, "unexpected IRQ, INT%d\n", hwirq);
 812         }
 813
 814         chained_irq_exit(chip, desc);
 815 }
 816
 817
 818 /**
 819  * rockchip_pcie_parse_dt - Parse Device Tree
 820  * @rockchip: PCIe port information
 821  *
 822  * Return: '0' on success and error value on failure
 823  */
 824 static int rockchip_pcie_parse_dt(struct rockchip_pcie *rockchip)
 825 {
 826         struct device *dev = rockchip->dev;
 827         struct platform_device *pdev = to_platform_device(dev);
 828         struct device_node *node = dev->of_node;
 829         struct resource *regs;
 830         int irq;
 831         int err;
 832
 833         regs = platform_get_resource_byname(pdev,
 834                                             IORESOURCE_MEM,
 835                                             "axi-base");
 836         rockchip->reg_base = devm_ioremap_resource(dev, regs);
 837         if (IS_ERR(rockchip->reg_base))
 838                 return PTR_ERR(rockchip->reg_base);
 839
 840         regs = platform_get_resource_byname(pdev,
 841                                             IORESOURCE_MEM,
 842                                             "apb-base");
 843         rockchip->apb_base = devm_ioremap_resource(dev, regs);
 844         if (IS_ERR(rockchip->apb_base))
 845                 return PTR_ERR(rockchip->apb_base);
 846
 847         rockchip->phy = devm_phy_get(dev, "pcie-phy");
 848         if (IS_ERR(rockchip->phy)) {
 849                 if (PTR_ERR(rockchip->phy) != -EPROBE_DEFER)
 850                         dev_err(dev, "missing phy\n");
 851                 return PTR_ERR(rockchip->phy);
 852         }
 853
 854         rockchip->lanes = 1;
 855         err = of_property_read_u32(node, "num-lanes", &rockchip->lanes);
 856         if (!err && (rockchip->lanes == 0 ||
 857                      rockchip->lanes == 3 ||
 858                      rockchip->lanes > 4)) {
 859                 dev_warn(dev, "invalid num-lanes, default to use one lane\n");
 860                 rockchip->lanes = 1;
 861         }
 862
 863         rockchip->link_gen = of_pci_get_max_link_speed(node);
 864         if (rockchip->link_gen < 0 || rockchip->link_gen > 2)
 865                 rockchip->link_gen = 2;
 866
 867         rockchip->core_rst = devm_reset_control_get(dev, "core");
 868         if (IS_ERR(rockchip->core_rst)) {
 869                 if (PTR_ERR(rockchip->core_rst) != -EPROBE_DEFER)
 870                         dev_err(dev, "missing core reset property in node\n");
 871                 return PTR_ERR(rockchip->core_rst);
 872         }
 873
 874         rockchip->mgmt_rst = devm_reset_control_get(dev, "mgmt");
 875         if (IS_ERR(rockchip->mgmt_rst)) {
 876                 if (PTR_ERR(rockchip->mgmt_rst) != -EPROBE_DEFER)
 877                         dev_err(dev, "missing mgmt reset property in node\n");
 878                 return PTR_ERR(rockchip->mgmt_rst);
 879         }
 880
 881         rockchip->mgmt_sticky_rst = devm_reset_control_get(dev, "mgmt-sticky");
 882         if (IS_ERR(rockchip->mgmt_sticky_rst)) {
 883                 if (PTR_ERR(rockchip->mgmt_sticky_rst) != -EPROBE_DEFER)
 884                         dev_err(dev, "missing mgmt-sticky reset property in node\n");
 885                 return PTR_ERR(rockchip->mgmt_sticky_rst);
 886         }
 887
 888         rockchip->pipe_rst = devm_reset_control_get(dev, "pipe");
 889         if (IS_ERR(rockchip->pipe_rst)) {
 890                 if (PTR_ERR(rockchip->pipe_rst) != -EPROBE_DEFER)
 891                         dev_err(dev, "missing pipe reset property in node\n");
 892                 return PTR_ERR(rockchip->pipe_rst);
 893         }
 894
 895         rockchip->pm_rst = devm_reset_control_get(dev, "pm");
 896         if (IS_ERR(rockchip->pm_rst)) {
 897                 if (PTR_ERR(rockchip->pm_rst) != -EPROBE_DEFER)
 898                         dev_err(dev, "missing pm reset property in node\n");
 899                 return PTR_ERR(rockchip->pm_rst);
 900         }
 901
 902         rockchip->pclk_rst = devm_reset_control_get(dev, "pclk");
 903         if (IS_ERR(rockchip->pclk_rst)) {
 904                 if (PTR_ERR(rockchip->pclk_rst) != -EPROBE_DEFER)
 905                         dev_err(dev, "missing pclk reset property in node\n");
 906                 return PTR_ERR(rockchip->pclk_rst);
 907         }
 908
 909         rockchip->aclk_rst = devm_reset_control_get(dev, "aclk");
 910         if (IS_ERR(rockchip->aclk_rst)) {
 911                 if (PTR_ERR(rockchip->aclk_rst) != -EPROBE_DEFER)
 912                         dev_err(dev, "missing aclk reset property in node\n");
 913                 return PTR_ERR(rockchip->aclk_rst);
 914         }
 915
 916         rockchip->ep_gpio = devm_gpiod_get(dev, "ep", GPIOD_OUT_HIGH);
 917         if (IS_ERR(rockchip->ep_gpio)) {
 918                 dev_err(dev, "missing ep-gpios property in node\n");
 919                 return PTR_ERR(rockchip->ep_gpio);
 920         }
 921
 922         rockchip->aclk_pcie = devm_clk_get(dev, "aclk");
 923         if (IS_ERR(rockchip->aclk_pcie)) {
 924                 dev_err(dev, "aclk clock not found\n");
 925                 return PTR_ERR(rockchip->aclk_pcie);
 926         }
 927
 928         rockchip->aclk_perf_pcie = devm_clk_get(dev, "aclk-perf");
 929         if (IS_ERR(rockchip->aclk_perf_pcie)) {
 930                 dev_err(dev, "aclk_perf clock not found\n");
 931                 return PTR_ERR(rockchip->aclk_perf_pcie);
 932         }
 933
 934         rockchip->hclk_pcie = devm_clk_get(dev, "hclk");
 935         if (IS_ERR(rockchip->hclk_pcie)) {
 936                 dev_err(dev, "hclk clock not found\n");
 937                 return PTR_ERR(rockchip->hclk_pcie);
 938         }
 939
 940         rockchip->clk_pcie_pm = devm_clk_get(dev, "pm");
 941         if (IS_ERR(rockchip->clk_pcie_pm)) {
 942                 dev_err(dev, "pm clock not found\n");
 943                 return PTR_ERR(rockchip->clk_pcie_pm);
 944         }
 945
 946         irq = platform_get_irq_byname(pdev, "sys");
 947         if (irq < 0) {
 948                 dev_err(dev, "missing sys IRQ resource\n");
 949                 return -EINVAL;
 950         }
 951
 952         err = devm_request_irq(dev, irq, rockchip_pcie_subsys_irq_handler,
 953                                IRQF_SHARED, "pcie-sys", rockchip);
 954         if (err) {
 955                 dev_err(dev, "failed to request PCIe subsystem IRQ\n");
 956                 return err;
 957         }
 958
 959         irq = platform_get_irq_byname(pdev, "legacy");
 960         if (irq < 0) {
 961                 dev_err(dev, "missing legacy IRQ resource\n");
 962                 return -EINVAL;
 963         }
 964
 965         irq_set_chained_handler_and_data(irq,
 966                                          rockchip_pcie_legacy_int_handler,
 967                                          rockchip);
 968
 969         irq = platform_get_irq_byname(pdev, "client");
 970         if (irq < 0) {
 971                 dev_err(dev, "missing client IRQ resource\n");
 972                 return -EINVAL;
 973         }
 974
 975         err = devm_request_irq(dev, irq, rockchip_pcie_client_irq_handler,
 976                                IRQF_SHARED, "pcie-client", rockchip);
 977         if (err) {
 978                 dev_err(dev, "failed to request PCIe client IRQ\n");
 979                 return err;
 980         }
 981
 982         rockchip->vpcie3v3 = devm_regulator_get_optional(dev, "vpcie3v3");
 983         if (IS_ERR(rockchip->vpcie3v3)) {
 984                 if (PTR_ERR(rockchip->vpcie3v3) == -EPROBE_DEFER)
 985                         return -EPROBE_DEFER;
 986                 dev_info(dev, "no vpcie3v3 regulator found\n");
 987         }
 988
 989         rockchip->vpcie1v8 = devm_regulator_get_optional(dev, "vpcie1v8");
 990         if (IS_ERR(rockchip->vpcie1v8)) {
 991                 if (PTR_ERR(rockchip->vpcie1v8) == -EPROBE_DEFER)
 992                         return -EPROBE_DEFER;
 993                 dev_info(dev, "no vpcie1v8 regulator found\n");
 994         }
 995
 996         rockchip->vpcie0v9 = devm_regulator_get_optional(dev, "vpcie0v9");
 997         if (IS_ERR(rockchip->vpcie0v9)) {
 998                 if (PTR_ERR(rockchip->vpcie0v9) == -EPROBE_DEFER)
 999                         return -EPROBE_DEFER;
1000                 dev_info(dev, "no vpcie0v9 regulator found\n");
1001         }
1002
1003         return 0;
1004 }
1005
1006 static int rockchip_pcie_set_vpcie(struct rockchip_pcie *rockchip)
1007 {
1008         struct device *dev = rockchip->dev;
1009         int err;
1010
1011         if (!IS_ERR(rockchip->vpcie3v3)) {
1012                 err = regulator_enable(rockchip->vpcie3v3);
1013                 if (err) {
1014                         dev_err(dev, "fail to enable vpcie3v3 regulator\n");
1015                         goto err_out;
1016                 }
1017         }
1018
1019         if (!IS_ERR(rockchip->vpcie1v8)) {
1020                 err = regulator_enable(rockchip->vpcie1v8);
1021                 if (err) {
1022                         dev_err(dev, "fail to enable vpcie1v8 regulator\n");
1023                         goto err_disable_3v3;
1024                 }
1025         }
1026
1027         if (!IS_ERR(rockchip->vpcie0v9)) {
1028                 err = regulator_enable(rockchip->vpcie0v9);
1029                 if (err) {
1030                         dev_err(dev, "fail to enable vpcie0v9 regulator\n");
1031                         goto err_disable_1v8;
1032                 }
1033         }
1034
1035         return 0;
1036
1037 err_disable_1v8:
1038         if (!IS_ERR(rockchip->vpcie1v8))
1039                 regulator_disable(rockchip->vpcie1v8);
1040 err_disable_3v3:
1041         if (!IS_ERR(rockchip->vpcie3v3))
1042                 regulator_disable(rockchip->vpcie3v3);
1043 err_out:
1044         return err;
1045 }
1046
1047 static void rockchip_pcie_enable_interrupts(struct rockchip_pcie *rockchip)
1048 {
1049         rockchip_pcie_write(rockchip, (PCIE_CLIENT_INT_CLI << 16) &
1050                             (~PCIE_CLIENT_INT_CLI), PCIE_CLIENT_INT_MASK);
1051         rockchip_pcie_write(rockchip, (u32)(~PCIE_CORE_INT),
1052                             PCIE_CORE_INT_MASK);
1053
1054         rockchip_pcie_enable_bw_int(rockchip);
1055 }
1056
1057 static int rockchip_pcie_intx_map(struct irq_domain *domain, unsigned int irq,
1058                                   irq_hw_number_t hwirq)
1059 {
1060         irq_set_chip_and_handler(irq, &dummy_irq_chip, handle_simple_irq);
1061         irq_set_chip_data(irq, domain->host_data);
1062
1063         return 0;
1064 }
1065
1066 static const struct irq_domain_ops intx_domain_ops = {
1067         .map = rockchip_pcie_intx_map,
1068 };
1069
1070 static int rockchip_pcie_init_irq_domain(struct rockchip_pcie *rockchip)
1071 {
1072         struct device *dev = rockchip->dev;
1073         struct device_node *intc = of_get_next_child(dev->of_node, NULL);
1074
1075         if (!intc) {
1076                 dev_err(dev, "missing child interrupt-controller node\n");
1077                 return -EINVAL;
1078         }
1079
1080         rockchip->irq_domain = irq_domain_add_linear(intc, 4,
1081                                                     &intx_domain_ops, rockchip);
1082         if (!rockchip->irq_domain) {
1083                 dev_err(dev, "failed to get a INTx IRQ domain\n");
1084                 return -EINVAL;
1085         }
1086
1087         return 0;
1088 }
1089
1090 static int rockchip_pcie_prog_ob_atu(struct rockchip_pcie *rockchip,
1091                                      int region_no, int type, u8 num_pass_bits,
1092                                      u32 lower_addr, u32 upper_addr)
1093 {
1094         u32 ob_addr_0;
1095         u32 ob_addr_1;
1096         u32 ob_desc_0;
1097         u32 aw_offset;
1098
1099         if (region_no >= MAX_AXI_WRAPPER_REGION_NUM)
1100                 return -EINVAL;
1101         if (num_pass_bits + 1 < 8)
1102                 return -EINVAL;
1103         if (num_pass_bits > 63)
1104                 return -EINVAL;
1105         if (region_no == 0) {
1106                 if (AXI_REGION_0_SIZE < (2ULL << num_pass_bits))
1107                         return -EINVAL;
1108         }
1109         if (region_no != 0) {
1110                 if (AXI_REGION_SIZE < (2ULL << num_pass_bits))
1111                         return -EINVAL;
1112         }
1113
1114         aw_offset = (region_no << OB_REG_SIZE_SHIFT);
1115
1116         ob_addr_0 = num_pass_bits & PCIE_CORE_OB_REGION_ADDR0_NUM_BITS;
1117         ob_addr_0 |= lower_addr & PCIE_CORE_OB_REGION_ADDR0_LO_ADDR;
1118         ob_addr_1 = upper_addr;
1119         ob_desc_0 = (1 << 23 | type);
1120
1121         rockchip_pcie_write(rockchip, ob_addr_0,
1122                             PCIE_CORE_OB_REGION_ADDR0 + aw_offset);
1123         rockchip_pcie_write(rockchip, ob_addr_1,
1124                             PCIE_CORE_OB_REGION_ADDR1 + aw_offset);
1125         rockchip_pcie_write(rockchip, ob_desc_0,
1126                             PCIE_CORE_OB_REGION_DESC0 + aw_offset);
1127         rockchip_pcie_write(rockchip, 0,
1128                             PCIE_CORE_OB_REGION_DESC1 + aw_offset);
1129
1130         return 0;
1131 }
1132
1133 static int rockchip_pcie_prog_ib_atu(struct rockchip_pcie *rockchip,
1134                                      int region_no, u8 num_pass_bits,
1135                                      u32 lower_addr, u32 upper_addr)
1136 {
1137         u32 ib_addr_0;
1138         u32 ib_addr_1;
1139         u32 aw_offset;
1140
1141         if (region_no > MAX_AXI_IB_ROOTPORT_REGION_NUM)
1142                 return -EINVAL;
1143         if (num_pass_bits + 1 < MIN_AXI_ADDR_BITS_PASSED)
1144                 return -EINVAL;
1145         if (num_pass_bits > 63)
1146                 return -EINVAL;
1147
1148         aw_offset = (region_no << IB_ROOT_PORT_REG_SIZE_SHIFT);
1149
1150         ib_addr_0 = num_pass_bits & PCIE_CORE_IB_REGION_ADDR0_NUM_BITS;
1151         ib_addr_0 |= (lower_addr << 8) & PCIE_CORE_IB_REGION_ADDR0_LO_ADDR;
1152         ib_addr_1 = upper_addr;
1153
1154         rockchip_pcie_write(rockchip, ib_addr_0, PCIE_RP_IB_ADDR0 + aw_offset);
1155         rockchip_pcie_write(rockchip, ib_addr_1, PCIE_RP_IB_ADDR1 + aw_offset);
1156
1157         return 0;
1158 }
1159
1160 static int rockchip_cfg_atu(struct rockchip_pcie *rockchip)
1161 {
1162         struct device *dev = rockchip->dev;
1163         int offset;
1164         int err;
1165         int reg_no;
1166
1167         for (reg_no = 0; reg_no < (rockchip->mem_size >> 20); reg_no++) {
1168                 err = rockchip_pcie_prog_ob_atu(rockchip, reg_no + 1,
1169                                                 AXI_WRAPPER_MEM_WRITE,
1170                                                 20 - 1,
1171                                                 rockchip->mem_bus_addr +
1172                                                 (reg_no << 20),
1173                                                 0);
1174                 if (err) {
1175                         dev_err(dev, "program RC mem outbound ATU failed\n");
1176                         return err;
1177                 }
1178         }
1179
1180         err = rockchip_pcie_prog_ib_atu(rockchip, 2, 32 - 1, 0x0, 0);
1181         if (err) {
1182                 dev_err(dev, "program RC mem inbound ATU failed\n");
1183                 return err;
1184         }
1185
1186         offset = rockchip->mem_size >> 20;
1187         for (reg_no = 0; reg_no < (rockchip->io_size >> 20); reg_no++) {
1188                 err = rockchip_pcie_prog_ob_atu(rockchip,
1189                                                 reg_no + 1 + offset,
1190                                                 AXI_WRAPPER_IO_WRITE,
1191                                                 20 - 1,
1192                                                 rockchip->io_bus_addr +
1193                                                 (reg_no << 20),
1194                                                 0);
1195                 if (err) {
1196                         dev_err(dev, "program RC io outbound ATU failed\n");
1197                         return err;
1198                 }
1199         }
1200
1201         /* assign message regions */
1202         rockchip_pcie_prog_ob_atu(rockchip, reg_no + 1 + offset,
1203                                   AXI_WRAPPER_NOR_MSG,
1204                                   20 - 1, 0, 0);
1205
1206         rockchip->msg_bus_addr = rockchip->mem_bus_addr +
1207                                         ((reg_no + offset) << 20);
1208         return err;
1209 }
1210
1211 static int rockchip_pcie_wait_l2(struct rockchip_pcie *rockchip)
1212 {
1213         u32 value;
1214         int err;
1215
1216         /* send PME_TURN_OFF message */
1217         writel(0x0, rockchip->msg_region + PCIE_RC_SEND_PME_OFF);
1218
1219         /* read LTSSM and wait for falling into L2 link state */
1220         err = readl_poll_timeout(rockchip->apb_base + PCIE_CLIENT_DEBUG_OUT_0,
1221                                  value, PCIE_LINK_IS_L2(value), 20,
1222                                  jiffies_to_usecs(5 * HZ));
1223         if (err) {
1224                 dev_err(rockchip->dev, "PCIe link enter L2 timeout!\n");
1225                 return err;
1226         }
1227
1228         return 0;
1229 }
1230
1231 static int rockchip_pcie_suspend_noirq(struct device *dev)
1232 {
1233         struct rockchip_pcie *rockchip = dev_get_drvdata(dev);
1234         int ret;
1235
1236         /* disable core and cli int since we don't need to ack PME_ACK */
1237         rockchip_pcie_write(rockchip, (PCIE_CLIENT_INT_CLI << 16) |
1238                             PCIE_CLIENT_INT_CLI, PCIE_CLIENT_INT_MASK);
1239         rockchip_pcie_write(rockchip, (u32)PCIE_CORE_INT, PCIE_CORE_INT_MASK);
1240
1241         ret = rockchip_pcie_wait_l2(rockchip);
1242         if (ret) {
1243                 rockchip_pcie_enable_interrupts(rockchip);
1244                 return ret;
1245         }
1246
1247         phy_power_off(rockchip->phy);
1248         phy_exit(rockchip->phy);
1249
1250         clk_disable_unprepare(rockchip->clk_pcie_pm);
1251         clk_disable_unprepare(rockchip->hclk_pcie);
1252         clk_disable_unprepare(rockchip->aclk_perf_pcie);
1253         clk_disable_unprepare(rockchip->aclk_pcie);
1254
1255         return ret;
1256 }
1257
1258 static int rockchip_pcie_resume_noirq(struct device *dev)
1259 {
1260         struct rockchip_pcie *rockchip = dev_get_drvdata(dev);
1261         int err;
1262
1263         clk_prepare_enable(rockchip->clk_pcie_pm);
1264         clk_prepare_enable(rockchip->hclk_pcie);
1265         clk_prepare_enable(rockchip->aclk_perf_pcie);
1266         clk_prepare_enable(rockchip->aclk_pcie);
1267
1268         err = rockchip_pcie_init_port(rockchip);
1269         if (err)
1270                 return err;
1271
1272         err = rockchip_cfg_atu(rockchip);
1273         if (err)
1274                 return err;
1275
1276         /* Need this to enter L1 again */
1277         rockchip_pcie_update_txcredit_mui(rockchip);
1278         rockchip_pcie_enable_interrupts(rockchip);
1279
1280         return 0;
1281 }
1282
1283 static int rockchip_pcie_probe(struct platform_device *pdev)
1284 {
1285         struct rockchip_pcie *rockchip;
1286         struct device *dev = &pdev->dev;
1287         struct pci_bus *bus, *child;
1288         struct resource_entry *win;
1289         resource_size_t io_base;
1290         struct resource *mem;
1291         struct resource *io;
1292         int err;
1293
1294         LIST_HEAD(res);
1295
1296         if (!dev->of_node)
1297                 return -ENODEV;
1298
1299         rockchip = devm_kzalloc(dev, sizeof(*rockchip), GFP_KERNEL);
1300         if (!rockchip)
1301                 return -ENOMEM;
1302
1303         platform_set_drvdata(pdev, rockchip);
1304         rockchip->dev = dev;
1305
1306         err = rockchip_pcie_parse_dt(rockchip);
1307         if (err)
1308                 return err;
1309
1310         err = clk_prepare_enable(rockchip->aclk_pcie);
1311         if (err) {
1312                 dev_err(dev, "unable to enable aclk_pcie clock\n");
1313                 goto err_aclk_pcie;
1314         }
1315
1316         err = clk_prepare_enable(rockchip->aclk_perf_pcie);
1317         if (err) {
1318                 dev_err(dev, "unable to enable aclk_perf_pcie clock\n");
1319                 goto err_aclk_perf_pcie;
1320         }
1321
1322         err = clk_prepare_enable(rockchip->hclk_pcie);
1323         if (err) {
1324                 dev_err(dev, "unable to enable hclk_pcie clock\n");
1325                 goto err_hclk_pcie;
1326         }
1327
1328         err = clk_prepare_enable(rockchip->clk_pcie_pm);
1329         if (err) {
1330                 dev_err(dev, "unable to enable hclk_pcie clock\n");
1331                 goto err_pcie_pm;
1332         }
1333
1334         err = rockchip_pcie_set_vpcie(rockchip);
1335         if (err) {
1336                 dev_err(dev, "failed to set vpcie regulator\n");
1337                 goto err_set_vpcie;
1338         }
1339
1340         err = rockchip_pcie_init_port(rockchip);
1341         if (err)
1342                 goto err_vpcie;
1343
1344         rockchip_pcie_enable_interrupts(rockchip);
1345
1346         err = rockchip_pcie_init_irq_domain(rockchip);
1347         if (err < 0)
1348                 goto err_vpcie;
1349
1350         err = of_pci_get_host_bridge_resources(dev->of_node, 0, 0xff,
1351                                                &res, &io_base);
1352         if (err)
1353                 goto err_vpcie;
1354
1355         err = devm_request_pci_bus_resources(dev, &res);
1356         if (err)
1357                 goto err_vpcie;
1358
1359         /* Get the I/O and memory ranges from DT */
1360         resource_list_for_each_entry(win, &res) {
1361                 switch (resource_type(win->res)) {
1362                 case IORESOURCE_IO:
1363                         io = win->res;
1364                         io->name = "I/O";
1365                         rockchip->io_size = resource_size(io);
1366                         rockchip->io_bus_addr = io->start - win->offset;
1367                         err = pci_remap_iospace(io, io_base);
1368                         if (err) {
1369                                 dev_warn(dev, "error %d: failed to map resource %pR\n",
1370                                          err, io);
1371                                 continue;
1372                         }
1373                         break;
1374                 case IORESOURCE_MEM:
1375                         mem = win->res;
1376                         mem->name = "MEM";
1377                         rockchip->mem_size = resource_size(mem);
1378                         rockchip->mem_bus_addr = mem->start - win->offset;
1379                         break;
1380                 case IORESOURCE_BUS:
1381                         rockchip->root_bus_nr = win->res->start;
1382                         break;
1383                 default:
1384                         continue;
1385                 }
1386         }
1387
1388         err = rockchip_cfg_atu(rockchip);
1389         if (err)
1390                 goto err_vpcie;
1391
1392         rockchip->msg_region = devm_ioremap(rockchip->dev,
1393                                             rockchip->msg_bus_addr, SZ_1M);
1394         if (!rockchip->msg_region) {
1395                 err = -ENOMEM;
1396                 goto err_vpcie;
1397         }
1398
1399         bus = pci_scan_root_bus(&pdev->dev, 0, &rockchip_pcie_ops, rockchip, &res);
1400         if (!bus) {
1401                 err = -ENOMEM;
1402                 goto err_vpcie;
1403         }
1404
1405         pci_bus_size_bridges(bus);
1406         pci_bus_assign_resources(bus);
1407         list_for_each_entry(child, &bus->children, node)
1408                 pcie_bus_configure_settings(child);
1409
1410         pci_bus_add_devices(bus);
1411         return err;
1412
1413 err_vpcie:
1414         if (!IS_ERR(rockchip->vpcie3v3))
1415                 regulator_disable(rockchip->vpcie3v3);
1416         if (!IS_ERR(rockchip->vpcie1v8))
1417                 regulator_disable(rockchip->vpcie1v8);
1418         if (!IS_ERR(rockchip->vpcie0v9))
1419                 regulator_disable(rockchip->vpcie0v9);
1420 err_set_vpcie:
1421         clk_disable_unprepare(rockchip->clk_pcie_pm);
1422 err_pcie_pm:
1423         clk_disable_unprepare(rockchip->hclk_pcie);
1424 err_hclk_pcie:
1425         clk_disable_unprepare(rockchip->aclk_perf_pcie);
1426 err_aclk_perf_pcie:
1427         clk_disable_unprepare(rockchip->aclk_pcie);
1428 err_aclk_pcie:
1429         return err;
1430 }
1431
1432 static const struct dev_pm_ops rockchip_pcie_pm_ops = {
1433         SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(rockchip_pcie_suspend_noirq,
1434                                       rockchip_pcie_resume_noirq)
1435 };
1436
1437 static const struct of_device_id rockchip_pcie_of_match[] = {
1438         { .compatible = "rockchip,rk3399-pcie", },
1439         {}
1440 };
1441
1442 static struct platform_driver rockchip_pcie_driver = {
1443         .driver = {
1444                 .name = "rockchip-pcie",
1445                 .of_match_table = rockchip_pcie_of_match,
1446                 .pm = &rockchip_pcie_pm_ops,
1447         },
1448         .probe = rockchip_pcie_probe,
1449
1450 };
1451 builtin_platform_driver(rockchip_pcie_driver);