drivers/pci/host/pcie-rockchip.c

   1 /*
   2  * Rockchip AXI PCIe host controller driver
   3  *
   4  * Copyright (c) 2016 Rockchip, Inc.
   5  *
   6  * Based on the xilinx PCIe driver
   7  *
   8  * Bits taken from Synopsys Designware Host controller driver and
   9  * ARM PCI Host generic driver.
  10  *
  11  * This program is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation, either version 2 of the License, or
  14  * (at your option) any later version.
  15  */
  16 #include <linux/clk.h>
  17 #include <linux/delay.h>
  18 #include <linux/gpio/consumer.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/irq.h>
  21 #include <linux/irqdomain.h>
  22 #include <linux/kernel.h>
  23 #include <linux/mfd/syscon.h>
  24 #include <linux/module.h>
  25 #include <linux/msi.h>
  26 #include <linux/of_address.h>
  27 #include <linux/of_device.h>
  28 #include <linux/of_pci.h>
  29 #include <linux/of_platform.h>
  30 #include <linux/of_irq.h>
  31 #include <linux/pci.h>
  32 #include <linux/platform_device.h>
  33 #include <linux/reset.h>
  34 #include <linux/regmap.h>
  35
  36 #define REF_CLK_100MHZ                  (100 * 1000 * 1000)
  37 #define PCIE_CLIENT_BASE                0x0
  38 #define PCIE_RC_CONFIG_BASE             0xa00000
  39 #define PCIE_CORE_CTRL_MGMT_BASE        0x900000
  40 #define PCIE_CORE_AXI_CONF_BASE         0xc00000
  41 #define PCIE_CORE_AXI_INBOUND_BASE      0xc00800
  42
  43 #define PCIE_CLIENT_BASIC_STATUS0       0x44
  44 #define PCIE_CLIENT_BASIC_STATUS1       0x48
  45 #define PCIE_CLIENT_INT_MASK            0x4c
  46 #define PCIE_CLIENT_INT_STATUS          0x50
  47 #define PCIE_CORE_INT_MASK              0x900210
  48 #define PCIE_CORE_INT_STATUS            0x90020c
  49
  50 /** Size of one AXI Region (not Region 0) */
  51 #define AXI_REGION_SIZE                 (0x1 << 20)
  52 /** Overall size of AXI area */
  53 #define AXI_OVERALL_SIZE                (64 * (0x1 << 20))
  54 /** Size of Region 0, equal to sum of sizes of other regions */
  55 #define AXI_REGION_0_SIZE               (32 * (0x1 << 20))
  56 #define OB_REG_SIZE_SHIFT               5
  57 #define IB_ROOT_PORT_REG_SIZE_SHIFT     3
  58
  59 #define AXI_WRAPPER_IO_WRITE            0x6
  60 #define AXI_WRAPPER_MEM_WRITE           0x2
  61 #define MAX_AXI_IB_ROOTPORT_REGION_NUM  3
  62 #define MIN_AXI_ADDR_BITS_PASSED        8
  63
  64 #define ROCKCHIP_PCIE_RPIFR1_INTR_MASK  GENMASK(8, 5)
  65 #define ROCKCHIP_PCIE_RPIFR1_INTR_SHIFT 5
  66 #define CLIENT_INTERRUPTS \
  67                 (LOC_INT | INTA | INTB | INTC | INTD |\
  68                  CORR_ERR | NFATAL_ERR | FATAL_ERR | DPA_INT | \
  69                  HOT_RESET | MSG_DONE | LEGACY_DONE)
  70 #define CORE_INTERRUPTS \
  71                 (PRFPE | CRFPE | RRPE | CRFO | RT | RTR | \
  72                  PE | MTR | UCR | FCE | CT | UTC | MMVC)
  73 #define PWR_STCG                        BIT(0)
  74 #define HOT_PLUG                        BIT(1)
  75 #define PHY_INT                         BIT(2)
  76 #define UDMA_INT                        BIT(3)
  77 #define LOC_INT                         BIT(4)
  78 #define INTA                            BIT(5)
  79 #define INTB                            BIT(6)
  80 #define INTC                            BIT(7)
  81 #define INTD                            BIT(8)
  82 #define CORR_ERR                        BIT(9)
  83 #define NFATAL_ERR                      BIT(10)
  84 #define FATAL_ERR                       BIT(11)
  85 #define DPA_INT                         BIT(12)
  86 #define HOT_RESET                       BIT(13)
  87 #define MSG_DONE                        BIT(14)
  88 #define LEGACY_DONE                     BIT(15)
  89 #define PRFPE                           BIT(0)
  90 #define CRFPE                           BIT(1)
  91 #define RRPE                            BIT(2)
  92 #define PRFO                            BIT(3)
  93 #define CRFO                            BIT(4)
  94 #define RT                              BIT(5)
  95 #define RTR                             BIT(6)
  96 #define PE                              BIT(7)
  97 #define MTR                             BIT(8)
  98 #define UCR                             BIT(9)
  99 #define FCE                             BIT(10)
 100 #define CT                              BIT(11)
 101 #define UTC                             BIT(18)
 102 #define MMVC                            BIT(19)
 103
 104 #define PCIE_ECAM_BUS(x)                (((x) & 0xFF) << 20)
 105 #define PCIE_ECAM_DEV(x)                (((x) & 0x1F) << 15)
 106 #define PCIE_ECAM_FUNC(x)               (((x) & 0x7) << 12)
 107 #define PCIE_ECAM_REG(x)                (((x) & 0xFFF) << 0)
 108 #define PCIE_ECAM_ADDR(bus, dev, func, reg) \
 109           (PCIE_ECAM_BUS(bus) | PCIE_ECAM_DEV(dev) | \
 110            PCIE_ECAM_FUNC(func) | PCIE_ECAM_REG(reg))
 111
 112 #define RC_REGION_0_ADDR_TRANS_H        0x00000000
 113 #define RC_REGION_0_ADDR_TRANS_L        0x00000000
 114 #define RC_REGION_0_PASS_BITS           (25 - 1)
 115 #define RC_REGION_1_ADDR_TRANS_H        0x00000000
 116 #define RC_REGION_1_ADDR_TRANS_L        0x00400000
 117 #define RC_REGION_1_PASS_BITS           (20 - 1)
 118 #define MAX_AXI_WRAPPER_REGION_NUM      33
 119 #define PCIE_CLIENT_CONF_ENABLE         BIT(0)
 120 #define PCIE_CLIENT_CONF_LANE_NUM(x)    ((x / 2) << 4)
 121 #define PCIE_CLIENT_MODE_RC             BIT(6)
 122 #define PCIE_CLIENT_GEN_SEL_2           BIT(7)
 123 #define PCIE_CLIENT_GEN_SEL_1           0x0
 124
 125 struct rockchip_pcie_port {
 126         void __iomem *reg_base;
 127         void __iomem *apb_base;
 128         struct regmap *grf;
 129         unsigned int pcie_conf;
 130         unsigned int pcie_status;
 131         unsigned int pcie_laneoff;
 132         struct reset_control *phy_rst;
 133         struct reset_control *core_rst;
 134         struct reset_control *mgmt_rst;
 135         struct reset_control *mgmt_sticky_rst;
 136         struct reset_control *pipe_rst;
 137         struct clk *aclk_pcie;
 138         struct clk *aclk_perf_pcie;
 139         struct clk *hclk_pcie;
 140         struct clk *clk_pciephy_ref;
 141         struct gpio_desc *ep_gpio;
 142         u32 lanes;
 143         resource_size_t         io_base;
 144         struct resource         *cfg;
 145         struct resource         *io;
 146         struct resource         *mem;
 147         struct resource         *busn;
 148         phys_addr_t             io_bus_addr;
 149         u32                     io_size;
 150         phys_addr_t             mem_bus_addr;
 151         u32                     mem_size;
 152         u8      root_bus_nr;
 153         int irq;
 154         struct msi_controller *msi;
 155
 156         struct device *dev;
 157         struct irq_domain *irq_domain;
 158 };
 159
 160 static inline u32 pcie_read(struct rockchip_pcie_port *port, u32 reg)
 161 {
 162         return readl(port->apb_base + reg);
 163 }
 164
 165 static inline void pcie_write(struct rockchip_pcie_port *port,
 166                               u32 val, u32 reg)
 167 {
 168         writel(val, port->apb_base + reg);
 169 }
 170
 171 static inline void pcie_pb_wr_cfg(struct rockchip_pcie_port *port,
 172                                   u32 addr, u32 data)
 173 {
 174         regmap_write(port->grf, port->pcie_conf,
 175                      (0x3ff << 17) | (data << 7) | (addr << 1));
 176         udelay(1);
 177         regmap_write(port->grf, port->pcie_conf,
 178                      (0x1 << 16) | (0x1 << 0));
 179         udelay(1);
 180         regmap_write(port->grf, port->pcie_conf,
 181                      (0x1 << 16) | (0x0 << 0));
 182 }
 183
 184 static inline u32 pcie_pb_rd_cfg(struct rockchip_pcie_port *port,
 185                                  u32 addr)
 186 {
 187         u32 val;
 188
 189         regmap_write(port->grf, port->pcie_conf,
 190                      (0x3ff << 17) | (addr << 1));
 191         regmap_read(port->grf, port->pcie_status, &val);
 192         return val;
 193 }
 194
 195 static int rockchip_pcie_valid_config(struct rockchip_pcie_port *pp,
 196                                       struct pci_bus *bus, int dev)
 197 {
 198         /* access only one slot on each root port */
 199         if (bus->number == pp->root_bus_nr && dev > 0)
 200                 return 0;
 201
 202         /*
 203          * do not read more than one device on the bus directly attached
 204          * to RC's (Virtual Bridge's) DS side.
 205          */
 206         if (bus->primary == pp->root_bus_nr && dev > 0)
 207                 return 0;
 208
 209         return 1;
 210 }
 211
 212 static int rockchip_pcie_rd_own_conf(struct rockchip_pcie_port *pp,
 213                                      int where, int size,
 214                                      u32 *val)
 215 {
 216         void __iomem *addr = pp->apb_base + PCIE_RC_CONFIG_BASE + where;
 217
 218         if ((uintptr_t)addr & (size - 1)) {
 219                 *val = 0;
 220                 return PCIBIOS_BAD_REGISTER_NUMBER;
 221         }
 222
 223         if (size == 4) {
 224                 *val = readl(addr);
 225         } else if (size == 2) {
 226                 *val = readw(addr);
 227         } else if (size == 1) {
 228                 *val = readb(addr);
 229         } else {
 230                 *val = 0;
 231                 return PCIBIOS_BAD_REGISTER_NUMBER;
 232         }
 233         return PCIBIOS_SUCCESSFUL;
 234 }
 235
 236 static int rockchip_pcie_wr_own_conf(struct rockchip_pcie_port *pp,
 237                                      int where, int size, u32 val)
 238 {
 239         u32 tmp;
 240         int offset;
 241
 242         offset = (where & (~0x3));
 243         tmp = readl(pp->apb_base + PCIE_RC_CONFIG_BASE + offset);
 244         if (size == 4) {
 245                 writel(val, pp->apb_base + PCIE_RC_CONFIG_BASE + where);
 246         } else if (size == 2) {
 247                 if (where & 0x2)
 248                         tmp = ((tmp & 0xffff) | (val << 16));
 249                 else
 250                         tmp = ((tmp & 0xffff0000) | val);
 251
 252                 writel(tmp, pp->apb_base + PCIE_RC_CONFIG_BASE + offset);
 253         } else if (size == 1) {
 254                 if ((where & 0x3) == 0)
 255                         tmp = ((tmp & (~0xff)) | val);
 256                 else if ((where & 0x3) == 1)
 257                         tmp = ((tmp & (~0xff00)) | (val << 8));
 258                 else if ((where & 0x3) == 2)
 259                         tmp = ((tmp & (~0xff0000)) | (val << 16));
 260                 else if ((where & 0x3) == 3)
 261                         tmp = ((tmp & (~0xff000000)) | (val << 24));
 262
 263                 writel(tmp, pp->apb_base + PCIE_RC_CONFIG_BASE + offset);
 264         } else {
 265                 return PCIBIOS_BAD_REGISTER_NUMBER;
 266         }
 267         return PCIBIOS_SUCCESSFUL;
 268 }
 269
 270 static int rockchip_pcie_rd_other_conf(struct rockchip_pcie_port *pp,
 271                                        struct pci_bus *bus, u32 devfn,
 272                                        int where, int size, u32 *val)
 273 {
 274         u32 busdev;
 275
 276         busdev = PCIE_ECAM_ADDR(bus->number, PCI_SLOT(devfn),
 277                                 PCI_FUNC(devfn), where);
 278
 279         if (busdev & (size - 1)) {
 280                 *val = 0;
 281                 return PCIBIOS_BAD_REGISTER_NUMBER;
 282         }
 283
 284         if (size == 4) {
 285                 *val = readl(pp->reg_base + busdev);
 286         } else if (size == 2) {
 287                 *val = readw(pp->reg_base + busdev);
 288         } else if (size == 1) {
 289                 *val = readb(pp->reg_base + busdev);
 290         } else {
 291                 *val = 0;
 292                 return PCIBIOS_BAD_REGISTER_NUMBER;
 293         }
 294         return PCIBIOS_SUCCESSFUL;
 295 }
 296
 297 static int rockchip_pcie_wr_other_conf(struct rockchip_pcie_port *pp,
 298                                        struct pci_bus *bus, u32 devfn,
 299                                        int where, int size, u32 val)
 300 {
 301         u32 busdev;
 302
 303         busdev = PCIE_ECAM_ADDR(bus->number, PCI_SLOT(devfn),
 304                                 PCI_FUNC(devfn), where);
 305         if (busdev & (size - 1))
 306                 return PCIBIOS_BAD_REGISTER_NUMBER;
 307
 308         if (size == 4)
 309                 writel(val, pp->reg_base + busdev);
 310         else if (size == 2)
 311                 writew(val, pp->reg_base + busdev);
 312         else if (size == 1)
 313                 writeb(val, pp->reg_base + busdev);
 314         else
 315                 return PCIBIOS_BAD_REGISTER_NUMBER;
 316
 317         return PCIBIOS_SUCCESSFUL;
 318 }
 319
 320 static int rockchip_pcie_rd_conf(struct pci_bus *bus, u32 devfn, int where,
 321                                  int size, u32 *val)
 322 {
 323         struct rockchip_pcie_port *pp = bus->sysdata;
 324         int ret;
 325
 326         if (rockchip_pcie_valid_config(pp, bus, PCI_SLOT(devfn)) == 0) {
 327                 *val = 0xffffffff;
 328                 return PCIBIOS_DEVICE_NOT_FOUND;
 329         }
 330
 331         if (bus->number != pp->root_bus_nr)
 332                 ret = rockchip_pcie_rd_other_conf(pp, bus, devfn,
 333                                                   where, size, val);
 334         else
 335                 ret = rockchip_pcie_rd_own_conf(pp, where, size, val);
 336
 337         return ret;
 338 }
 339
 340 static int rockchip_pcie_wr_conf(struct pci_bus *bus, u32 devfn,
 341                                  int where, int size, u32 val)
 342 {
 343         struct rockchip_pcie_port *pp = bus->sysdata;
 344         int ret;
 345
 346         if (rockchip_pcie_valid_config(pp, bus, PCI_SLOT(devfn)) == 0)
 347                 return PCIBIOS_DEVICE_NOT_FOUND;
 348
 349         if (bus->number != pp->root_bus_nr)
 350                 ret = rockchip_pcie_wr_other_conf(pp, bus, devfn,
 351                                                   where, size, val);
 352         else
 353                 ret = rockchip_pcie_wr_own_conf(pp, where, size, val);
 354
 355         return ret;
 356 }
 357
 358 static struct pci_ops rockchip_pcie_ops = {
 359         .read = rockchip_pcie_rd_conf,
 360         .write = rockchip_pcie_wr_conf,
 361 };
 362
 363 /**
 364  * rockchip_pcie_init_port - Initialize hardware
 365  * @port: PCIe port information
 366  */
 367 static int rockchip_pcie_init_port(struct rockchip_pcie_port *port)
 368 {
 369         int err;
 370         u32 status;
 371         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
 372
 373         gpiod_set_value(port->ep_gpio, 0);
 374
 375         /* Make sure PCIe relate block is in reset state */
 376         err = reset_control_assert(port->phy_rst);
 377         if (err) {
 378                 dev_err(port->dev, "assert phy_rst err %d\n", err);
 379                 return err;
 380         }
 381         err = reset_control_assert(port->core_rst);
 382         if (err) {
 383                 dev_err(port->dev, "assert core_rst err %d\n", err);
 384                 return err;
 385         }
 386         err = reset_control_assert(port->mgmt_rst);
 387         if (err) {
 388                 dev_err(port->dev, "assert mgmt_rst err %d\n", err);
 389                 return err;
 390         }
 391         err = reset_control_assert(port->mgmt_sticky_rst);
 392         if (err) {
 393                 dev_err(port->dev, "assert mgmt_sticky_rst err %d\n", err);
 394                 return err;
 395         }
 396         err = reset_control_assert(port->pipe_rst);
 397         if (err) {
 398                 dev_err(port->dev, "assert pipe_rst err %d\n", err);
 399                 return err;
 400         }
 401
 402         pcie_write(port, (0xf << 20) | (0x1 << 16) | PCIE_CLIENT_GEN_SEL_2 |
 403                           (0x1 << 19) | (0x1 << 3) |
 404                           PCIE_CLIENT_MODE_RC |
 405                           PCIE_CLIENT_CONF_LANE_NUM(port->lanes) |
 406                           PCIE_CLIENT_CONF_ENABLE, PCIE_CLIENT_BASE);
 407
 408         err = reset_control_deassert(port->phy_rst);
 409         if (err) {
 410                 dev_err(port->dev, "deassert phy_rst err %d\n", err);
 411                 return err;
 412         }
 413         regmap_write(port->grf, port->pcie_conf,
 414                      (0x3f << 17) | (0x10 << 1));
 415         err = -EINVAL;
 416         while (time_before(jiffies, timeout)) {
 417                 regmap_read(port->grf, port->pcie_status, &status);
 418                 if ((status & (1 << 9))) {
 419                         dev_info(port->dev, "pll locked!\n");
 420                         err = 0;
 421                         break;
 422                 }
 423         }
 424         if (err) {
 425                 dev_err(port->dev, "pll lock timeout!\n");
 426                 return err;
 427         }
 428         pcie_pb_wr_cfg(port, 0x10, 0x8);
 429         pcie_pb_wr_cfg(port, 0x12, 0x8);
 430
 431         err = -ETIMEDOUT;
 432         while (time_before(jiffies, timeout)) {
 433                 regmap_read(port->grf, port->pcie_status, &status);
 434                 if (!(status & (1 << 10))) {
 435                         dev_info(port->dev, "pll output enable done!\n");
 436                         err = 0;
 437                         break;
 438                 }
 439         }
 440
 441         if (err) {
 442                 dev_err(port->dev, "pll output enable timeout!\n");
 443                 return err;
 444         }
 445
 446         regmap_write(port->grf, port->pcie_conf,
 447                      (0x3f << 17) | (0x10 << 1));
 448         err = -EINVAL;
 449         while (time_before(jiffies, timeout)) {
 450                 regmap_read(port->grf, port->pcie_status, &status);
 451                 if ((status & (1 << 9))) {
 452                         dev_info(port->dev, "pll relocked!\n");
 453                         err = 0;
 454                         break;
 455                 }
 456         }
 457         if (err) {
 458                 dev_err(port->dev, "pll relock timeout!\n");
 459                 return err;
 460         }
 461
 462         err = reset_control_deassert(port->core_rst);
 463         if (err) {
 464                 dev_err(port->dev, "deassert core_rst err %d\n", err);
 465                 return err;
 466         }
 467         err = reset_control_deassert(port->mgmt_rst);
 468         if (err) {
 469                 dev_err(port->dev, "deassert mgmt_rst err %d\n", err);
 470                 return err;
 471         }
 472         err = reset_control_deassert(port->mgmt_sticky_rst);
 473         if (err) {
 474                 dev_err(port->dev, "deassert mgmt_sticky_rst err %d\n", err);
 475                 return err;
 476         }
 477         err = reset_control_deassert(port->pipe_rst);
 478         if (err) {
 479                 dev_err(port->dev, "deassert pipe_rst err %d\n", err);
 480                 return err;
 481         }
 482
 483         pcie_write(port, 1 << 17 | 1 << 1, PCIE_CLIENT_BASE);
 484
 485         gpiod_set_value(port->ep_gpio, 1);
 486         err = -ETIMEDOUT;
 487         while (time_before(jiffies, timeout)) {
 488                 status = pcie_read(port, PCIE_CLIENT_BASIC_STATUS1);
 489                 if (((status >> 20) & 0x3) == 0x3) {
 490                         dev_info(port->dev, "pcie link training gen1 pass!\n");
 491                         err = 0;
 492                         break;
 493                 }
 494         }
 495         if (err) {
 496                 dev_err(port->dev, "pcie link training gen1 timeout!\n");
 497                 return err;
 498         }
 499
 500         status = pcie_read(port, 0x9000d0);
 501         status |= 0x20;
 502         pcie_write(port, status, 0x9000d0);
 503         err = -ETIMEDOUT;
 504         while (time_before(jiffies, timeout)) {
 505                 status = pcie_read(port, PCIE_CORE_CTRL_MGMT_BASE);
 506                 if (((status >> 3) & 0x3) == 0x1) {
 507                         dev_info(port->dev, "pcie link training gen2 pass!\n");
 508                         err = 0;
 509                         break;
 510                 }
 511         }
 512         if (err)
 513                 dev_dbg(port->dev, "pcie link training gen2 timeout, force to gen1!\n");
 514
 515         if (((status >> 3) & 0x3) == 0x0)
 516                 dev_info(port->dev, "pcie link 2.5!\n");
 517         if (((status >> 3) & 0x3) == 0x1)
 518                 dev_info(port->dev, "pcie link 5.0!\n");
 519
 520         status = pcie_read(port, PCIE_CORE_CTRL_MGMT_BASE);
 521         status =  0x1 << ((status >> 1) & 0x3);
 522         dev_info(port->dev, "current link width is x%d\n", status);
 523
 524         status = pcie_pb_rd_cfg(port, 0x30);
 525         if (!((status >> 11) & 0x1))
 526                 dev_dbg(port->dev, "lane A is used\n");
 527         else
 528                 regmap_write(port->grf, port->pcie_laneoff,
 529                              (0x1 << 19) | (0x1 << 3));
 530
 531         status = pcie_pb_rd_cfg(port, 0x31);
 532         if (!((status >> 11) & 0x1))
 533                 dev_dbg(port->dev, "lane B is used\n");
 534         else
 535                 regmap_write(port->grf, port->pcie_laneoff,
 536                              (0x2 << 19) | (0x2 << 3));
 537
 538         status = pcie_pb_rd_cfg(port, 0x32);
 539         if (!((status >> 11) & 0x1))
 540                 dev_dbg(port->dev, "lane C is used\n");
 541         else
 542                 regmap_write(port->grf, port->pcie_laneoff,
 543                              (0x4 << 19) | (0x4 << 3));
 544
 545         status = pcie_pb_rd_cfg(port, 0x33);
 546         if (!((status >> 11) & 0x1))
 547                 dev_dbg(port->dev, "lane D is used\n");
 548         else
 549                 regmap_write(port->grf, port->pcie_laneoff,
 550                              (0x8 << 19) | (0x8 << 3));
 551         return 0;
 552 }
 553
 554 /**
 555  * rockchip_pcie_parse_dt - Parse Device tree
 556  * @port: PCIe port information
 557  *
 558  * Return: '0' on success and error value on failure
 559  */
 560 static int rockchip_pcie_parse_dt(struct rockchip_pcie_port *port)
 561 {
 562         struct device *dev = port->dev;
 563         struct device_node *node = dev->of_node;
 564         struct resource regs;
 565         unsigned int pcie_conf;
 566         unsigned int pcie_status;
 567         unsigned int pcie_laneoff;
 568         int err;
 569
 570         err = of_address_to_resource(node, 0, &regs);
 571         if (err) {
 572                 dev_err(dev, "missing \"reg\" property\n");
 573                 return err;
 574         }
 575
 576         port->reg_base = devm_ioremap_resource(dev, &regs);
 577         if (IS_ERR(port->reg_base))
 578                 return PTR_ERR(port->reg_base);
 579
 580         err = of_address_to_resource(node, 1, &regs);
 581         if (err) {
 582                 dev_err(dev, "missing \"reg\" property\n");
 583                 return err;
 584         }
 585
 586         port->apb_base = devm_ioremap_resource(dev, &regs);
 587         if (IS_ERR(port->apb_base))
 588                 return PTR_ERR(port->apb_base);
 589
 590         port->grf = syscon_regmap_lookup_by_phandle(dev->of_node,
 591                                                     "rockchip,grf");
 592         if (IS_ERR(port->grf)) {
 593                 dev_err(dev, "Missing rockchip,grf property\n");
 594                 return PTR_ERR(port->grf);
 595         }
 596
 597         if (of_property_read_u32(node, "pcie-conf", &pcie_conf)) {
 598                 dev_err(dev, "missing pcie-conf property in node %s\n",
 599                         node->name);
 600                 return -EINVAL;
 601         }
 602
 603         port->pcie_conf = pcie_conf;
 604
 605         if (of_property_read_u32(node, "pcie-status", &pcie_status)) {
 606                 dev_err(dev, "missing pcie-status property in node %s\n",
 607                         node->name);
 608                 return -EINVAL;
 609         }
 610
 611         port->pcie_status = pcie_status;
 612
 613         if (of_property_read_u32(node, "pcie-laneoff", &pcie_laneoff)) {
 614                 dev_err(dev, "missing pcie-laneoff property in node %s\n",
 615                         node->name);
 616                 return -EINVAL;
 617         }
 618
 619         port->pcie_laneoff = pcie_laneoff;
 620
 621         port->lanes = 1;
 622         err = of_property_read_u32(node, "num-lanes", &port->lanes);
 623         if (!err && ((port->lanes == 0) ||
 624                      (port->lanes == 3) ||
 625                      (port->lanes > 4))) {
 626                 dev_info(dev, "invalid num-lanes, default use one lane\n");
 627                 port->lanes = 1;
 628         }
 629
 630         port->phy_rst = devm_reset_control_get(dev, "phy-rst");
 631         if (IS_ERR(port->phy_rst)) {
 632                 if (PTR_ERR(port->phy_rst) != -EPROBE_DEFER)
 633                         dev_err(dev, "missing phy-rst property in node %s\n",
 634                                 node->name);
 635                 err = PTR_ERR(port->phy_rst);
 636                 goto err_aclk_pcie;
 637         }
 638
 639         port->core_rst = devm_reset_control_get(dev, "core-rst");
 640         if (IS_ERR(port->core_rst)) {
 641                 if (PTR_ERR(port->core_rst) != -EPROBE_DEFER)
 642                         dev_err(dev, "missing core-rst property in node %s\n",
 643                                 node->name);
 644                 err = PTR_ERR(port->core_rst);
 645                 goto err_aclk_pcie;
 646         }
 647
 648         port->mgmt_rst = devm_reset_control_get(dev, "mgmt-rst");
 649         if (IS_ERR(port->mgmt_rst)) {
 650                 if (PTR_ERR(port->mgmt_rst) != -EPROBE_DEFER)
 651                         dev_err(dev, "missing mgmt-rst property in node %s\n",
 652                                 node->name);
 653                 err = PTR_ERR(port->mgmt_rst);
 654                 goto err_aclk_pcie;
 655         }
 656
 657         port->mgmt_sticky_rst = devm_reset_control_get(dev, "mgmt-sticky-rst");
 658         if (IS_ERR(port->mgmt_sticky_rst)) {
 659                 if (PTR_ERR(port->mgmt_sticky_rst) != -EPROBE_DEFER)
 660                         dev_err(dev, "missing mgmt-sticky-rst property in node %s\n",
 661                                 node->name);
 662                 err = PTR_ERR(port->mgmt_sticky_rst);
 663                 goto err_aclk_pcie;
 664         }
 665
 666         port->pipe_rst = devm_reset_control_get(dev, "pipe-rst");
 667         if (IS_ERR(port->pipe_rst)) {
 668                 if (PTR_ERR(port->pipe_rst) != -EPROBE_DEFER)
 669                         dev_err(dev, "missing pipe-rst property in node %s\n",
 670                                 node->name);
 671                 err = PTR_ERR(port->pipe_rst);
 672                 goto err_aclk_pcie;
 673         }
 674
 675         port->ep_gpio = gpiod_get(dev, "ep", GPIOD_OUT_HIGH);
 676         if (IS_ERR(port->ep_gpio)) {
 677                 dev_err(dev, "missing ep-gpios property in node %s\n",
 678                         node->name);
 679                 return PTR_ERR(port->ep_gpio);
 680         }
 681
 682         port->aclk_pcie = devm_clk_get(dev, "aclk_pcie");
 683         if (IS_ERR(port->aclk_pcie)) {
 684                 dev_err(dev, "aclk_pcie clock not found.\n");
 685                 return PTR_ERR(port->aclk_pcie);
 686         }
 687
 688         port->aclk_perf_pcie = devm_clk_get(dev, "aclk_perf_pcie");
 689         if (IS_ERR(port->aclk_perf_pcie)) {
 690                 dev_err(dev, "aclk_perf_pcie clock not found.\n");
 691                 return PTR_ERR(port->aclk_perf_pcie);
 692         }
 693
 694         port->hclk_pcie = devm_clk_get(dev, "hclk_pcie");
 695         if (IS_ERR(port->hclk_pcie)) {
 696                 dev_err(dev, "hclk_pcie clock not found.\n");
 697                 return PTR_ERR(port->hclk_pcie);
 698         }
 699
 700         port->clk_pciephy_ref = devm_clk_get(dev, "clk_pciephy_ref");
 701         if (IS_ERR(port->clk_pciephy_ref)) {
 702                 dev_err(dev, "clk_pciephy_ref clock not found.\n");
 703                 return PTR_ERR(port->clk_pciephy_ref);
 704         }
 705
 706         err = clk_prepare_enable(port->aclk_pcie);
 707         if (err) {
 708                 dev_err(dev, "Unable to enable aclk_pcie clock.\n");
 709                 goto err_aclk_pcie;
 710         }
 711
 712         err = clk_prepare_enable(port->aclk_perf_pcie);
 713         if (err) {
 714                 dev_err(dev, "Unable to enable aclk_perf_pcie clock.\n");
 715                 goto err_aclk_perf_pcie;
 716         }
 717
 718         err = clk_prepare_enable(port->hclk_pcie);
 719         if (err) {
 720                 dev_err(dev, "Unable to enable hclk_pcie clock.\n");
 721                 goto err_hclk_pcie;
 722         }
 723
 724         err = clk_prepare_enable(port->clk_pciephy_ref);
 725         if (err) {
 726                 dev_err(dev, "Unable to enable hclk_pcie clock.\n");
 727                 goto err_pciephy_ref;
 728         }
 729
 730         return 0;
 731
 732 err_pciephy_ref:
 733         clk_disable_unprepare(port->hclk_pcie);
 734 err_hclk_pcie:
 735         clk_disable_unprepare(port->aclk_perf_pcie);
 736 err_aclk_perf_pcie:
 737         clk_disable_unprepare(port->aclk_pcie);
 738 err_aclk_pcie:
 739         return err;
 740 }
 741
 742 static void rockchip_pcie_msi_enable(struct rockchip_pcie_port *pp)
 743 {
 744         struct device_node *msi_node;
 745
 746         msi_node = of_parse_phandle(pp->dev->of_node,
 747                                     "msi-parent", 0);
 748         if (!msi_node)
 749                 return;
 750
 751         pp->msi = of_pci_find_msi_chip_by_node(msi_node);
 752         of_node_put(msi_node);
 753
 754         if (pp->msi)
 755                 pp->msi->dev = pp->dev;
 756 }
 757
 758 static void rockchip_pcie_enable_interrupts(struct rockchip_pcie_port *pp)
 759 {
 760         pcie_write(pp, (CLIENT_INTERRUPTS << 16) &
 761                    (~CLIENT_INTERRUPTS), PCIE_CLIENT_INT_MASK);
 762         pcie_write(pp, CORE_INTERRUPTS, PCIE_CORE_INT_MASK);
 763 }
 764
 765 static int rockchip_pcie_intx_map(struct irq_domain *domain, unsigned int irq,
 766                                   irq_hw_number_t hwirq)
 767 {
 768         irq_set_chip_and_handler(irq, &dummy_irq_chip, handle_simple_irq);
 769         irq_set_chip_data(irq, domain->host_data);
 770
 771         return 0;
 772 }
 773
 774 static const struct irq_domain_ops intx_domain_ops = {
 775         .map = rockchip_pcie_intx_map,
 776 };
 777
 778 static int rockchip_pcie_init_irq_domain(struct rockchip_pcie_port *pp)
 779 {
 780         struct device *dev = pp->dev;
 781         struct device_node *node = dev->of_node;
 782         struct device_node *pcie_intc_node =  of_get_next_child(node, NULL);
 783
 784         if (!pcie_intc_node) {
 785                 dev_err(dev, "No PCIe Intc node found\n");
 786                 return PTR_ERR(pcie_intc_node);
 787         }
 788         pp->irq_domain = irq_domain_add_linear(pcie_intc_node, 4,
 789                                                &intx_domain_ops, pp);
 790         if (!pp->irq_domain) {
 791                 dev_err(dev, "Failed to get a INTx IRQ domain\n");
 792                 return PTR_ERR(pp->irq_domain);
 793         }
 794
 795         return 0;
 796 }
 797
 798 static irqreturn_t rockchip_pcie_subsys_irq_handler(int irq, void *arg)
 799 {
 800         struct rockchip_pcie_port *pp = arg;
 801         u32 reg;
 802         u32 sub_reg;
 803
 804         reg = pcie_read(pp, PCIE_CLIENT_INT_STATUS);
 805         if (reg & LOC_INT) {
 806                 dev_dbg(pp->dev, "local interrupt recived\n");
 807                 sub_reg = pcie_read(pp, PCIE_CORE_INT_STATUS);
 808                 if (sub_reg & PRFPE)
 809                         dev_dbg(pp->dev, "Parity error detected while reading from the PNP Receive FIFO RAM\n");
 810
 811                 if (sub_reg & CRFPE)
 812                         dev_dbg(pp->dev, "Parity error detected while reading from the Completion Receive FIFO RAM\n");
 813
 814                 if (sub_reg & RRPE)
 815                         dev_dbg(pp->dev, "Parity error detected while reading from Replay Buffer RAM\n");
 816
 817                 if (sub_reg & PRFO)
 818                         dev_dbg(pp->dev, "Overflow occurred in the PNP Receive FIFO\n");
 819
 820                 if (sub_reg & CRFO)
 821                         dev_dbg(pp->dev, "Overflow occurred in the Completion Receive FIFO\n");
 822
 823                 if (sub_reg & RT)
 824                         dev_dbg(pp->dev, "Replay timer timed out\n");
 825
 826                 if (sub_reg & RTR)
 827                         dev_dbg(pp->dev, "Replay timer rolled over after 4 transmissions of the same TLP\n");
 828
 829                 if (sub_reg & PE)
 830                         dev_dbg(pp->dev, "Phy error detected on receive side\n");
 831
 832                 if (sub_reg & MTR)
 833                         dev_dbg(pp->dev, "Malformed TLP received from the link\n");
 834
 835                 if (sub_reg & UCR)
 836                         dev_dbg(pp->dev, "Malformed TLP received from the link\n");
 837
 838                 if (sub_reg & FCE)
 839                         dev_dbg(pp->dev, "An error was observed in the flow control advertisements from the other side\n");
 840
 841                 if (sub_reg & CT)
 842                         dev_dbg(pp->dev, "A request timed out waiting for completion\n");
 843
 844                 if (sub_reg & UTC)
 845                         dev_dbg(pp->dev, "Unmapped TC error\n");
 846
 847                 if (sub_reg & MMVC)
 848                         dev_dbg(pp->dev, "MSI mask register changes\n");
 849
 850                 pcie_write(pp, sub_reg, PCIE_CORE_INT_STATUS);
 851         }
 852
 853         pcie_write(pp, reg, PCIE_CLIENT_INT_STATUS);
 854
 855         return IRQ_HANDLED;
 856 }
 857
 858 static irqreturn_t rockchip_pcie_client_irq_handler(int irq, void *arg)
 859 {
 860         struct rockchip_pcie_port *pp = arg;
 861         u32 reg;
 862
 863         reg = pcie_read(pp, PCIE_CLIENT_INT_STATUS);
 864         if (reg & LEGACY_DONE)
 865                 dev_dbg(pp->dev, "legacy done interrupt recived\n");
 866
 867         if (reg & MSG_DONE)
 868                 dev_dbg(pp->dev, "message done interrupt recived\n");
 869
 870         if (reg & HOT_RESET)
 871                 dev_dbg(pp->dev, "hot reset interrupt recived\n");
 872
 873         if (reg & DPA_INT)
 874                 dev_dbg(pp->dev, "dpa interrupt recived\n");
 875
 876         if (reg & FATAL_ERR)
 877                 dev_dbg(pp->dev, "fatal error interrupt recived\n");
 878
 879         if (reg & DPA_INT)
 880                 dev_dbg(pp->dev, "no fatal error interrupt recived\n");
 881
 882         if (reg & CORR_ERR)
 883                 dev_dbg(pp->dev, "correctable error interrupt recived\n");
 884
 885         pcie_write(pp, reg, PCIE_CLIENT_INT_STATUS);
 886
 887         return IRQ_HANDLED;
 888 }
 889
 890 static irqreturn_t rockchip_pcie_legacy_int_handler(int irq, void *arg)
 891 {
 892         struct rockchip_pcie_port *pp = arg;
 893         u32 reg;
 894
 895         reg = pcie_read(pp, PCIE_CLIENT_INT_STATUS);
 896         reg = (reg & ROCKCHIP_PCIE_RPIFR1_INTR_MASK) >>
 897                ROCKCHIP_PCIE_RPIFR1_INTR_SHIFT;
 898         generic_handle_irq(irq_find_mapping(pp->irq_domain, ffs(reg)));
 899
 900         pcie_write(pp, reg, PCIE_CLIENT_INT_STATUS);
 901         return IRQ_HANDLED;
 902 }
 903
 904 static int rockchip_pcie_prog_ob_atu(struct rockchip_pcie_port *pp,
 905                                      int region_no,
 906                                      int type, u8 num_pass_bits,
 907                                      u32 lower_addr, u32 upper_addr)
 908 {
 909         u32 ob_addr_0 = 0;
 910         u32 ob_addr_1 = 0;
 911         u32 ob_desc_0 = 0;
 912         u32 ob_desc_1 = 0;
 913         void __iomem *aw_base;
 914
 915         if (!pp)
 916                 return -EINVAL;
 917         if (region_no >= MAX_AXI_WRAPPER_REGION_NUM)
 918                 return -EINVAL;
 919         if ((num_pass_bits + 1) < 8)
 920                 return -EINVAL;
 921         if (num_pass_bits > 63)
 922                 return -EINVAL;
 923         if (region_no == 0) {
 924                 if (AXI_REGION_0_SIZE < (2ULL << num_pass_bits))
 925                 return -EINVAL;
 926         }
 927         if (region_no != 0) {
 928                 if (AXI_REGION_SIZE < (2ULL << num_pass_bits))
 929                 return -EINVAL;
 930         }
 931         aw_base = pp->apb_base + PCIE_CORE_AXI_CONF_BASE;
 932         aw_base += (region_no << OB_REG_SIZE_SHIFT);
 933
 934         ob_addr_0 = (ob_addr_0 &
 935                      ~0x0000003fU) | (num_pass_bits &
 936                      0x0000003fU);
 937         ob_addr_0 = (ob_addr_0 &
 938                      ~0xffffff00U) | (lower_addr & 0xffffff00U);
 939         ob_addr_1 = upper_addr;
 940         ob_desc_0 = (1 << 23 | type);
 941
 942         writel(ob_addr_0, aw_base);
 943         writel(ob_addr_1, aw_base + 0x4);
 944         writel(ob_desc_0, aw_base + 0x8);
 945         writel(ob_desc_1, aw_base + 0xc);
 946
 947         return 0;
 948 }
 949
 950 static int rockchip_pcie_prog_ib_atu(struct rockchip_pcie_port *pp,
 951                                      int region_no,
 952                                      u8 num_pass_bits,
 953                                      u32 lower_addr,
 954                                      u32 upper_addr)
 955 {
 956         u32 ib_addr_0 = 0;
 957         u32 ib_addr_1 = 0;
 958         void __iomem *aw_base;
 959
 960         if (!pp)
 961                 return -EINVAL;
 962         if (region_no > MAX_AXI_IB_ROOTPORT_REGION_NUM)
 963                 return -EINVAL;
 964         if ((num_pass_bits + 1) < MIN_AXI_ADDR_BITS_PASSED)
 965                 return -EINVAL;
 966         if (num_pass_bits > 63)
 967                 return -EINVAL;
 968         aw_base = pp->apb_base + PCIE_CORE_AXI_INBOUND_BASE;
 969         aw_base += (region_no << IB_ROOT_PORT_REG_SIZE_SHIFT);
 970         ib_addr_0 = (ib_addr_0 &
 971                      ~0x0000003fU) | (num_pass_bits &
 972                      0x0000003fU);
 973
 974         ib_addr_0 = (ib_addr_0 & ~0xffffff00U) |
 975                      ((lower_addr << 8) & 0xffffff00U);
 976         ib_addr_1 = upper_addr;
 977         writel(ib_addr_0, aw_base);
 978         writel(ib_addr_1, aw_base + 0x4);
 979
 980         return 0;
 981 }
 982
 983 static int rockchip_pcie_probe(struct platform_device *pdev)
 984 {
 985         struct rockchip_pcie_port *port;
 986         struct device *dev = &pdev->dev;
 987         struct pci_bus *bus, *child;
 988         struct resource_entry *win;
 989         int reg_no;
 990         int err = 0;
 991         int irq;
 992         LIST_HEAD(res);
 993
 994         if (!dev->of_node)
 995                 return -ENODEV;
 996
 997         port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL);
 998         if (!port)
 999                 return -ENOMEM;
1000
1001         irq = platform_get_irq_byname(pdev, "pcie-sys");
1002         if (irq < 0) {
1003                 dev_err(dev, "missing pcie_sys IRQ resource\n");
1004                 return -EINVAL;
1005         }
1006         err = devm_request_irq(dev, irq, rockchip_pcie_subsys_irq_handler,
1007                                IRQF_SHARED, "pcie-sys", port);
1008         if (err) {
1009                 dev_err(dev, "failed to request pcie subsystem irq\n");
1010                 return err;
1011         }
1012
1013         port->irq = platform_get_irq_byname(pdev, "pcie-legacy");
1014         if (port->irq < 0) {
1015                 dev_err(dev, "missing pcie_legacy IRQ resource\n");
1016                 return -EINVAL;
1017         }
1018         err = devm_request_irq(dev, port->irq,
1019                                rockchip_pcie_legacy_int_handler,
1020                                IRQF_SHARED,
1021                                "pcie-legacy",
1022                                port);
1023         if (err) {
1024                 dev_err(&pdev->dev, "failed to request pcie-legacy irq\n");
1025                 return err;
1026         }
1027
1028         irq = platform_get_irq_byname(pdev, "pcie-client");
1029         if (irq < 0) {
1030                 dev_err(dev, "missing pcie-client IRQ resource\n");
1031                 return -EINVAL;
1032         }
1033         err = devm_request_irq(dev, irq, rockchip_pcie_client_irq_handler,
1034                                IRQF_SHARED, "pcie-client", port);
1035         if (err) {
1036                 dev_err(dev, "failed to request pcie client irq\n");
1037                 return err;
1038         }
1039
1040         port->dev = dev;
1041         err = rockchip_pcie_parse_dt(port);
1042         if (err) {
1043                 dev_err(dev, "Parsing DT failed\n");
1044                 return err;
1045         }
1046
1047         err = rockchip_pcie_init_port(port);
1048         if (err)
1049                 return err;
1050
1051         platform_set_drvdata(pdev, port);
1052
1053         rockchip_pcie_enable_interrupts(port);
1054         if (!IS_ENABLED(CONFIG_PCI_MSI)) {
1055                 err = rockchip_pcie_init_irq_domain(port);
1056                 if (err < 0)
1057                         return err;
1058         }
1059
1060         err = of_pci_get_host_bridge_resources(dev->of_node, 0, 0xff,
1061                                                &res, &port->io_base);
1062         if (err)
1063                 return err;
1064         /* Get the I/O and memory ranges from DT */
1065         resource_list_for_each_entry(win, &res) {
1066                 switch (resource_type(win->res)) {
1067                 case IORESOURCE_IO:
1068                         port->io = win->res;
1069                         port->io->name = "I/O";
1070                         port->io_size = resource_size(port->io);
1071                         port->io_bus_addr = port->io->start - win->offset;
1072                         err = pci_remap_iospace(port->io, port->io_base);
1073                         if (err) {
1074                                 dev_warn(port->dev, "error %d: failed to map resource %pR\n",
1075                                          err, port->io);
1076                                 continue;
1077                         }
1078                         break;
1079                 case IORESOURCE_MEM:
1080                         port->mem = win->res;
1081                         port->mem->name = "MEM";
1082                         port->mem_size = resource_size(port->mem);
1083                         port->mem_bus_addr = port->mem->start - win->offset;
1084                         break;
1085                 case 0:
1086                         port->cfg = win->res;
1087                         break;
1088                 case IORESOURCE_BUS:
1089                         port->busn = win->res;
1090                         break;
1091                 default:
1092                         continue;
1093                 }
1094         }
1095
1096         pcie_write(port, 0x6040000, PCIE_RC_CONFIG_BASE + 0x8);
1097         pcie_write(port, 0x0, PCIE_CORE_CTRL_MGMT_BASE + 0x300);
1098
1099         pcie_write(port, (RC_REGION_0_ADDR_TRANS_L + RC_REGION_0_PASS_BITS),
1100                    PCIE_CORE_AXI_CONF_BASE);
1101         pcie_write(port, RC_REGION_0_ADDR_TRANS_H,
1102                    PCIE_CORE_AXI_CONF_BASE + 0x4);
1103         pcie_write(port, 0x0080000a, PCIE_CORE_AXI_CONF_BASE + 0x8);
1104         pcie_write(port, 0x00000000, PCIE_CORE_AXI_CONF_BASE + 0xc);
1105
1106         for (reg_no = 0; reg_no < (port->mem_size >> 20); reg_no++) {
1107                 err = rockchip_pcie_prog_ob_atu(port, reg_no + 1,
1108                                                 AXI_WRAPPER_MEM_WRITE,
1109                                                 20 - 1,
1110                                                 port->mem_bus_addr +
1111                                                         (reg_no << 20),
1112                                                 0);
1113                 if (err) {
1114                         dev_err(dev, "Program RC outbound atu failed\n");
1115                         return err;
1116                 }
1117         }
1118
1119         err = rockchip_pcie_prog_ib_atu(port, 2, 32 - 1, 0x0, 0);
1120         if (err) {
1121                 dev_err(dev, "Program RC inbound atu failed\n");
1122                 return err;
1123         }
1124
1125         rockchip_pcie_msi_enable(port);
1126
1127         port->root_bus_nr = port->busn->start;
1128         if (IS_ENABLED(CONFIG_PCI_MSI)) {
1129                 bus = pci_scan_root_bus_msi(port->dev, port->root_bus_nr,
1130                                             &rockchip_pcie_ops, port, &res,
1131                                             port->msi);
1132         } else {
1133                 bus = pci_scan_root_bus(&pdev->dev, 0,
1134                                         &rockchip_pcie_ops, port, &res);
1135         }
1136         if (!bus)
1137                 return -ENOMEM;
1138
1139         if (!pci_has_flag(PCI_PROBE_ONLY)) {
1140                 pci_bus_size_bridges(bus);
1141                 pci_bus_assign_resources(bus);
1142                 list_for_each_entry(child, &bus->children, node)
1143                         pcie_bus_configure_settings(child);
1144         }
1145
1146         pci_bus_add_devices(bus);
1147
1148         return err;
1149 }
1150
1151 static int rockchip_pcie_remove(struct platform_device *pdev)
1152 {
1153         struct rockchip_pcie_port *port = platform_get_drvdata(pdev);
1154
1155         clk_disable_unprepare(port->hclk_pcie);
1156         clk_disable_unprepare(port->aclk_perf_pcie);
1157         clk_disable_unprepare(port->aclk_pcie);
1158         clk_disable_unprepare(port->clk_pciephy_ref);
1159
1160         return 0;
1161 }
1162
1163 static const struct of_device_id rockchip_pcie_of_match[] = {
1164         { .compatible = "rockchip,rk3399-pcie", },
1165         {}
1166 };
1167
1168 static struct platform_driver rockchip_pcie_driver = {
1169         .driver = {
1170                 .name = "rockchip-pcie",
1171                 .of_match_table = rockchip_pcie_of_match,
1172                 .suppress_bind_attrs = true,
1173         },
1174         .probe = rockchip_pcie_probe,
1175         .remove = rockchip_pcie_remove,
1176 };
1177 module_platform_driver(rockchip_pcie_driver);
1178
1179 MODULE_AUTHOR("Rockchip Inc");
1180 MODULE_DESCRIPTION("Rockchip AXI PCIe driver");
1181 MODULE_LICENSE("GPL v2");