sys/arm64/rockchip/rk_pcie.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2019 Michal Meloun <mmel@FreeBSD.org>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  */
  28
  29 /* Rockchip PCIe controller driver */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/bus.h>
  37 #include <sys/gpio.h>
  38 #include <sys/proc.h>
  39 #include <sys/kernel.h>
  40 #include <sys/lock.h>
  41 #include <sys/malloc.h>
  42 #include <sys/module.h>
  43 #include <sys/mutex.h>
  44 #include <sys/rman.h>
  45
  46 #include <machine/bus.h>
  47 #include <machine/intr.h>
  48 #include <machine/resource.h>
  49
  50 #include <dev/extres/clk/clk.h>
  51 #include <dev/extres/hwreset/hwreset.h>
  52 #include <dev/extres/phy/phy.h>
  53 #include <dev/extres/regulator/regulator.h>
  54 #include <dev/gpio/gpiobusvar.h>
  55 #include <dev/ofw/ofw_bus.h>
  56 #include <dev/ofw/ofw_bus_subr.h>
  57 #include <dev/ofw/ofw_pci.h>
  58 #include <dev/ofw/ofwpci.h>
  59 #include <dev/pci/pcivar.h>
  60 #include <dev/pci/pcireg.h>
  61 #include <dev/pci/pcib_private.h>
  62
  63 #include <dev/ofw/ofw_bus.h>
  64
  65 #include "pcib_if.h"
  66
  67 #define ATU_CFG_BUS(x)          (((x) & 0x0ff) << 20)
  68 #define ATU_CFG_SLOT(x)         (((x) & 0x01f) << 15)
  69 #define ATU_CFG_FUNC(x)         (((x) & 0x007) << 12)
  70 #define ATU_CFG_REG(x)          (((x) & 0xfff) << 0)
  71
  72 #define ATU_TYPE_MEM            0x2
  73 #define ATU_TYPE_IO             0x6
  74 #define ATU_TYPE_CFG0           0xA
  75 #define ATU_TYPE_CFG1           0xB
  76 #define ATY_TYPE_NOR_MSG        0xC
  77
  78 #define ATU_OB_REGIONS          33
  79 #define ATU_OB_REGION_SHIFT     20
  80 #define ATU_OB_REGION_SIZE      (1 << ATU_OB_REGION_SHIFT)
  81 #define ATU_OB_REGION_0_SIZE    (( ATU_OB_REGIONS - 1) * ATU_OB_REGION_SIZE)
  82
  83 #define ATU_IB_REGIONS          3
  84
  85 #define PCIE_CLIENT_BASIC_STRAP_CONF            0x000000
  86 #define  STRAP_CONF_GEN_2                               (1 << 7)
  87 #define  STRAP_CONF_MODE_RC                             (1 << 6)
  88 #define  STRAP_CONF_LANES(n)                            ((((n) / 2) & 0x3) << 4)
  89 #define  STRAP_CONF_ARI_EN                              (1 << 3)
  90 #define  STRAP_CONF_SR_IOV_EN                           (1 << 2)
  91 #define  STRAP_CONF_LINK_TRAIN_EN                       (1 << 1)
  92 #define  STRAP_CONF_CONF_EN                             (1 << 0)
  93 #define PCIE_CLIENT_HOT_RESET_CTRL              0x000018
  94 #define  HOT_RESET_CTRL_LINK_DOWN_RESET                 (1 << 1)
  95 #define  HOT_RESET_CTRL_HOT_RESET_IN                    (1 << 0)
  96 #define PCIE_CLIENT_BASIC_STATUS0               0x000044
  97 #define PCIE_CLIENT_BASIC_STATUS1               0x000048
  98 #define  STATUS1_LINK_ST_GET(x)                         (((x) >> 20) & 0x3)
  99 #define   STATUS1_LINK_ST_UP                            3
 100 #define PCIE_CLIENT_INT_MASK                    0x00004C
 101 #define PCIE_CLIENT_INT_STATUS                  0x000050
 102 #define  PCIE_CLIENT_INT_LEGACY_DONE                    (1 << 15)
 103 #define  PCIE_CLIENT_INT_MSG                            (1 << 14)
 104 #define  PCIE_CLIENT_INT_HOT_RST                        (1 << 13)
 105 #define  PCIE_CLIENT_INT_DPA                            (1 << 12)
 106 #define  PCIE_CLIENT_INT_FATAL_ERR                      (1 << 11)
 107 #define  PCIE_CLIENT_INT_NFATAL_ERR                     (1 << 10)
 108 #define  PCIE_CLIENT_INT_CORR_ERR                       (1 << 9)
 109 #define  PCIE_CLIENT_INT_INTD                           (1 << 8)
 110 #define  PCIE_CLIENT_INT_INTC                           (1 << 7)
 111 #define  PCIE_CLIENT_INT_INTB                           (1 << 6)
 112 #define  PCIE_CLIENT_INT_INTA                           (1 << 5)
 113 #define  PCIE_CLIENT_INT_LOCAL                          (1 << 4)
 114 #define  PCIE_CLIENT_INT_UDMA                           (1 << 3)
 115 #define  PCIE_CLIENT_INT_PHY                            (1 << 2)
 116 #define  PCIE_CLIENT_INT_HOT_PLUG                       (1 << 1)
 117 #define  PCIE_CLIENT_INT_PWR_STCG                       (1 << 0)
 118 #define  PCIE_CLIENT_INT_LEGACY                 (PCIE_CLIENT_INT_INTA | \
 119                                                 PCIE_CLIENT_INT_INTB | \
 120                                                 PCIE_CLIENT_INT_INTC | \
 121                                                 PCIE_CLIENT_INT_INTD)
 122
 123 #define PCIE_CORE_CTRL0                         0x900000
 124 #define  CORE_CTRL_LANES_GET(x)                         (((x) >> 20) & 0x3)
 125 #define PCIE_CORE_CTRL1                         0x900004
 126 #define PCIE_CORE_CONFIG_VENDOR                 0x900044
 127 #define PCIE_CORE_INT_STATUS                    0x90020c
 128 #define  PCIE_CORE_INT_PRFPE                            (1 << 0)
 129 #define  PCIE_CORE_INT_CRFPE                            (1 << 1)
 130 #define  PCIE_CORE_INT_RRPE                             (1 << 2)
 131 #define  PCIE_CORE_INT_PRFO                             (1 << 3)
 132 #define  PCIE_CORE_INT_CRFO                             (1 << 4)
 133 #define  PCIE_CORE_INT_RT                               (1 << 5)
 134 #define  PCIE_CORE_INT_RTR                              (1 << 6)
 135 #define  PCIE_CORE_INT_PE                               (1 << 7)
 136 #define  PCIE_CORE_INT_MTR                              (1 << 8)
 137 #define  PCIE_CORE_INT_UCR                              (1 << 9)
 138 #define  PCIE_CORE_INT_FCE                              (1 << 10)
 139 #define  PCIE_CORE_INT_CT                               (1 << 11)
 140 #define  PCIE_CORE_INT_UTC                              (1 << 18)
 141 #define  PCIE_CORE_INT_MMVC                             (1 << 19)
 142 #define PCIE_CORE_INT_MASK                      0x900210
 143 #define PCIE_CORE_PHY_FUNC_CONF                 0x9002C0
 144 #define PCIE_CORE_RC_BAR_CONF                   0x900300
 145
 146 #define PCIE_RC_CONFIG_STD_BASE                 0x800000
 147 #define PCIE_RC_CONFIG_PRIV_BASE                0xA00000
 148 #define PCIE_RC_CONFIG_DCSR                     0xA000C8
 149 #define  PCIE_RC_CONFIG_DCSR_MPS_MASK                   (0x7 << 5)
 150 #define  PCIE_RC_CONFIG_DCSR_MPS_128                    (0 << 5)
 151 #define  PCIE_RC_CONFIG_DCSR_MPS_256                    (1 << 5)
 152 #define  PCIE_RC_CONFIG_LINK_CAP                0xA00CC
 153 #define   PCIE_RC_CONFIG_LINK_CAP_L0S                   (1 << 10)
 154
 155 #define PCIE_RC_CONFIG_LCS                      0xA000D0
 156 #define PCIE_RC_CONFIG_THP_CAP                  0xA00274
 157 #define  PCIE_RC_CONFIG_THP_CAP_NEXT_MASK               0xFFF00000
 158
 159 #define PCIE_CORE_OB_ADDR0(n)                   (0xC00000 + 0x20 * (n) + 0x00)
 160 #define PCIE_CORE_OB_ADDR1(n)                   (0xC00000 + 0x20 * (n) + 0x04)
 161 #define PCIE_CORE_OB_DESC0(n)                   (0xC00000 + 0x20 * (n) + 0x08)
 162 #define PCIE_CORE_OB_DESC1(n)                   (0xC00000 + 0x20 * (n) + 0x0C)
 163 #define PCIE_CORE_OB_DESC2(n)                   (0xC00000 + 0x20 * (n) + 0x10)
 164 #define PCIE_CORE_OB_DESC3(n)                   (0xC00000 + 0x20 * (n) + 0x14)
 165
 166 #define PCIE_CORE_IB_ADDR0(n)                   (0xC00800 + 0x8 * (n) + 0x00)
 167 #define PCIE_CORE_IB_ADDR1(n)                   (0xC00800 + 0x8 * (n) + 0x04)
 168
 169 #define PRIV_CFG_RD4(sc, reg)                                           \
 170     (uint32_t)rk_pcie_local_cfg_read(sc, true, reg, 4)
 171 #define PRIV_CFG_RD2(sc, reg)                                           \
 172     (uint16_t)rk_pcie_local_cfg_read(sc, true, reg, 2)
 173 #define PRIV_CFG_RD1(sc, reg)                                           \
 174     (uint8_t)rk_pcie_local_cfg_read(sc, true, reg, 1)
 175 #define PRIV_CFG_WR4(sc, reg, val)                                      \
 176     rk_pcie_local_cfg_write(sc, true, reg, val, 4)
 177 #define PRIV_CFG_WR2(sc, reg, val)                                      \
 178     rk_pcie_local_cfg_write(sc, true, reg, val, 2)
 179 #define PRIV_CFG_WR1(sc, reg, val)                                      \
 180     rk_pcie_local_cfg_write(sc, true, reg, val, 1)
 181
 182 #define APB_WR4(_sc, _r, _v)    bus_write_4((_sc)->apb_mem_res, (_r), (_v))
 183 #define APB_RD4(_sc, _r)        bus_read_4((_sc)->apb_mem_res, (_r))
 184
 185 #define MAX_LANES       4
 186
 187 #define RK_PCIE_ENABLE_MSI
 188 #define RK_PCIE_ENABLE_MSIX
 189
 190 struct rk_pcie_softc {
 191         struct ofw_pci_softc    ofw_pci;        /* Must be first */
 192
 193         struct resource         *axi_mem_res;
 194         struct resource         *apb_mem_res;
 195         struct resource         *client_irq_res;
 196         struct resource         *legacy_irq_res;
 197         struct resource         *sys_irq_res;
 198         void                    *client_irq_cookie;
 199         void                    *legacy_irq_cookie;
 200         void                    *sys_irq_cookie;
 201
 202         device_t                dev;
 203         phandle_t               node;
 204         struct mtx              mtx;
 205
 206         struct ofw_pci_range    mem_range;
 207         struct ofw_pci_range    pref_mem_range;
 208         struct ofw_pci_range    io_range;
 209
 210         bool                    coherent;
 211         bus_dma_tag_t           dmat;
 212
 213         int                     num_lanes;
 214         bool                    link_is_gen2;
 215         bool                    no_l0s;
 216
 217         u_int                   bus_start;
 218         u_int                   bus_end;
 219         u_int                   root_bus;
 220         u_int                   sub_bus;
 221
 222         regulator_t             supply_12v;
 223         regulator_t             supply_3v3;
 224         regulator_t             supply_1v8;
 225         regulator_t             supply_0v9;
 226         hwreset_t               hwreset_core;
 227         hwreset_t               hwreset_mgmt;
 228         hwreset_t               hwreset_mgmt_sticky;
 229         hwreset_t               hwreset_pipe;
 230         hwreset_t               hwreset_pm;
 231         hwreset_t               hwreset_aclk;
 232         hwreset_t               hwreset_pclk;
 233         clk_t                   clk_aclk;
 234         clk_t                   clk_aclk_perf;
 235         clk_t                   clk_hclk;
 236         clk_t                   clk_pm;
 237         phy_t                   phys[MAX_LANES];
 238         gpio_pin_t              gpio_ep;
 239 };
 240
 241 /* Compatible devices. */
 242 static struct ofw_compat_data compat_data[] = {
 243         {"rockchip,rk3399-pcie", 1},
 244         {NULL,                   0},
 245 };
 246
 247 static uint32_t
 248 rk_pcie_local_cfg_read(struct rk_pcie_softc *sc, bool priv, u_int reg,
 249     int bytes)
 250 {
 251         uint32_t val;
 252         bus_addr_t base;
 253
 254         if (priv)
 255                 base = PCIE_RC_CONFIG_PRIV_BASE;
 256         else
 257                 base = PCIE_RC_CONFIG_STD_BASE;
 258
 259         switch (bytes) {
 260         case 4:
 261                 val = bus_read_4(sc->apb_mem_res, base + reg);
 262                 break;
 263         case 2:
 264                 val = bus_read_2(sc->apb_mem_res, base + reg);
 265                 break;
 266         case 1:
 267                 val = bus_read_1(sc->apb_mem_res, base + reg);
 268                 break;
 269         default:
 270                 val = 0xFFFFFFFF;
 271         }
 272         return (val);
 273 }
 274
 275 static void
 276 rk_pcie_local_cfg_write(struct rk_pcie_softc *sc, bool priv, u_int reg,
 277     uint32_t val, int bytes)
 278 {
 279         uint32_t val2;
 280         bus_addr_t base;
 281
 282         if (priv)
 283                 base = PCIE_RC_CONFIG_PRIV_BASE;
 284         else
 285                 base = PCIE_RC_CONFIG_STD_BASE;
 286
 287         switch (bytes) {
 288         case 4:
 289                 bus_write_4(sc->apb_mem_res, base + reg, val);
 290                 break;
 291         case 2:
 292                 val2 = bus_read_4(sc->apb_mem_res, base + (reg & ~3));
 293                 val2 &= ~(0xffff << ((reg & 3) << 3));
 294                 val2 |= ((val & 0xffff) << ((reg & 3) << 3));
 295                 bus_write_4(sc->apb_mem_res, base + (reg & ~3), val2);
 296                 break;
 297         case 1:
 298                 val2 = bus_read_4(sc->apb_mem_res, base + (reg & ~3));
 299                 val2 &= ~(0xff << ((reg & 3) << 3));
 300                 val2 |= ((val & 0xff) << ((reg & 3) << 3));
 301                 bus_write_4(sc->apb_mem_res, base + (reg & ~3), val2);
 302                 break;
 303         }
 304 }
 305
 306 static bool
 307 rk_pcie_check_dev(struct rk_pcie_softc *sc, u_int bus, u_int slot, u_int func,
 308     u_int reg)
 309 {
 310         uint32_t val;
 311
 312         if (bus < sc->bus_start || bus > sc->bus_end || slot > PCI_SLOTMAX ||
 313             func > PCI_FUNCMAX || reg > PCIE_REGMAX)
 314                 return (false);
 315
 316         if (bus == sc->root_bus) {
 317                 /* we have only 1 device with 1 function root port */
 318                 if (slot > 0 || func > 0)
 319                         return (false);
 320                 return (true);
 321         }
 322
 323         /* link is needed for accessing non-root busses */
 324         val = APB_RD4(sc, PCIE_CLIENT_BASIC_STATUS1);
 325         if (STATUS1_LINK_ST_GET(val) != STATUS1_LINK_ST_UP)
 326                 return (false);
 327
 328         /* only one device can be on first subordinate bus */
 329         if (bus == sc->sub_bus  && slot != 0 )
 330                 return (false);
 331         return (true);
 332 }
 333
 334 static void
 335 rk_pcie_map_out_atu(struct rk_pcie_softc *sc, int idx, int type,
 336    int num_bits, uint64_t pa)
 337 {
 338         uint32_t addr0;
 339         uint64_t max_size;
 340
 341         /* Check HW constrains */
 342         max_size = idx == 0 ? ATU_OB_REGION_0_SIZE: ATU_OB_REGION_SIZE;
 343         KASSERT(idx <  ATU_OB_REGIONS, ("Invalid region index: %d\n", idx));
 344         KASSERT(num_bits  >= 7 &&  num_bits <= 63,
 345             ("Bit width of region is invalid: %d\n", num_bits));
 346         KASSERT(max_size <= (1ULL << (num_bits + 1)),
 347             ("Bit width is invalid for given region[%d]: %d\n", idx, num_bits));
 348
 349         addr0 = (uint32_t)pa & 0xFFFFFF00;
 350         addr0 |= num_bits;
 351         APB_WR4(sc, PCIE_CORE_OB_ADDR0(idx), addr0);
 352         APB_WR4(sc, PCIE_CORE_OB_ADDR1(idx), (uint32_t)(pa >> 32));
 353         APB_WR4(sc, PCIE_CORE_OB_DESC0(idx), 1 << 23 | type);
 354         APB_WR4(sc, PCIE_CORE_OB_DESC1(idx), sc->root_bus);
 355
 356         /* Readback for sync */
 357         APB_RD4(sc, PCIE_CORE_OB_DESC1(idx));
 358 }
 359
 360 static void
 361 rk_pcie_map_cfg_atu(struct rk_pcie_softc *sc, int idx, int type)
 362 {
 363
 364         /* Check HW constrains */
 365         KASSERT(idx <  ATU_OB_REGIONS, ("Invalid region index: %d\n", idx));
 366
 367         /*
 368          * Config window is only 25 bits width, so we cannot encode full bus
 369          * range into it. Remaining bits of bus number should be taken from
 370          * DESC1 field.
 371          */
 372         APB_WR4(sc, PCIE_CORE_OB_ADDR0(idx), 25 - 1);
 373         APB_WR4(sc, PCIE_CORE_OB_ADDR1(idx), 0);
 374         APB_WR4(sc, PCIE_CORE_OB_DESC0(idx), 1 << 23 |  type);
 375         APB_WR4(sc, PCIE_CORE_OB_DESC1(idx), sc->root_bus);
 376
 377         /* Readback for sync */
 378         APB_RD4(sc, PCIE_CORE_OB_DESC1(idx));
 379
 380 }
 381
 382 static void
 383 rk_pcie_map_in_atu(struct rk_pcie_softc *sc, int idx, int num_bits, uint64_t pa)
 384 {
 385         uint32_t addr0;
 386
 387         /* Check HW constrains */
 388         KASSERT(idx <  ATU_IB_REGIONS, ("Invalid region index: %d\n", idx));
 389         KASSERT(num_bits  >= 7 &&  num_bits <= 63,
 390             ("Bit width of region is invalid: %d\n", num_bits));
 391
 392         addr0 = (uint32_t)pa & 0xFFFFFF00;
 393         addr0 |= num_bits;
 394         APB_WR4(sc, PCIE_CORE_IB_ADDR0(idx), addr0);
 395         APB_WR4(sc, PCIE_CORE_IB_ADDR1(idx), (uint32_t)(pa >> 32));
 396
 397         /* Readback for sync */
 398         APB_RD4(sc, PCIE_CORE_IB_ADDR1(idx));
 399 }
 400
 401 static int
 402 rk_pcie_decode_ranges(struct rk_pcie_softc *sc, struct ofw_pci_range *ranges,
 403      int nranges)
 404 {
 405         int i;
 406
 407         for (i = 0; i < nranges; i++) {
 408                 if ((ranges[i].pci_hi & OFW_PCI_PHYS_HI_SPACEMASK)  ==
 409                     OFW_PCI_PHYS_HI_SPACE_IO) {
 410                         if (sc->io_range.size != 0) {
 411                                 device_printf(sc->dev,
 412                                     "Duplicated IO range found in DT\n");
 413                                 return (ENXIO);
 414                         }
 415                         sc->io_range = ranges[i];
 416                 }
 417                 if (((ranges[i].pci_hi & OFW_PCI_PHYS_HI_SPACEMASK) ==
 418                     OFW_PCI_PHYS_HI_SPACE_MEM64))  {
 419                         if (ranges[i].pci_hi & OFW_PCI_PHYS_HI_PREFETCHABLE) {
 420                                 if (sc->pref_mem_range.size != 0) {
 421                                         device_printf(sc->dev,
 422                                             "Duplicated memory range found "
 423                                             "in DT\n");
 424                                         return (ENXIO);
 425                                 }
 426                                 sc->pref_mem_range = ranges[i];
 427                         } else {
 428                                 if (sc->mem_range.size != 0) {
 429                                         device_printf(sc->dev,
 430                                             "Duplicated memory range found "
 431                                             "in DT\n");
 432                                         return (ENXIO);
 433                                 }
 434                                 sc->mem_range = ranges[i];
 435                         }
 436                 }
 437         }
 438         if (sc->mem_range.size == 0) {
 439                 device_printf(sc->dev,
 440                     " At least memory range should be defined in DT.\n");
 441                 return (ENXIO);
 442         }
 443         return (0);
 444 }
 445
 446 /*-----------------------------------------------------------------------------
 447  *
 448  *  P C I B   I N T E R F A C E
 449  */
 450 static uint32_t
 451 rk_pcie_read_config(device_t dev, u_int bus, u_int slot,
 452     u_int func, u_int reg, int bytes)
 453 {
 454         struct rk_pcie_softc *sc;
 455         uint32_t d32, data;
 456         uint16_t d16;
 457         uint8_t d8;
 458         uint64_t addr;
 459         int type, ret;
 460
 461         sc = device_get_softc(dev);
 462
 463         if (!rk_pcie_check_dev(sc, bus, slot, func, reg))
 464                 return (0xFFFFFFFFU);
 465         if (bus == sc->root_bus)
 466                 return (rk_pcie_local_cfg_read(sc, false, reg, bytes));
 467
 468         addr = ATU_CFG_BUS(bus) | ATU_CFG_SLOT(slot) | ATU_CFG_FUNC(func) |
 469             ATU_CFG_REG(reg);
 470         type = bus == sc->sub_bus ? ATU_TYPE_CFG0: ATU_TYPE_CFG1;
 471         rk_pcie_map_cfg_atu(sc, 0, type);
 472
 473         ret = -1;
 474         switch (bytes) {
 475         case 1:
 476                 ret = bus_peek_1(sc->axi_mem_res, addr, &d8);
 477                 data = d8;
 478                 break;
 479         case 2:
 480                 ret = bus_peek_2(sc->axi_mem_res, addr, &d16);
 481                 data = d16;
 482                 break;
 483         case 4:
 484                 ret = bus_peek_4(sc->axi_mem_res, addr, &d32);
 485                 data = d32;
 486                 break;
 487         }
 488         if (ret != 0)
 489                 data = 0xFFFFFFFF;
 490         return (data);
 491 }
 492
 493 static void
 494 rk_pcie_write_config(device_t dev, u_int bus, u_int slot,
 495     u_int func, u_int reg, uint32_t val, int bytes)
 496 {
 497         struct rk_pcie_softc *sc;
 498         uint64_t addr;
 499         int type;
 500
 501         sc = device_get_softc(dev);
 502
 503         if (!rk_pcie_check_dev(sc, bus, slot, func, reg))
 504                 return;
 505
 506         if (bus == sc->root_bus)
 507                 return (rk_pcie_local_cfg_write(sc, false,  reg, val, bytes));
 508
 509         addr = ATU_CFG_BUS(bus) | ATU_CFG_SLOT(slot) | ATU_CFG_FUNC(func) |
 510             ATU_CFG_REG(reg);
 511         type = bus == sc->sub_bus ? ATU_TYPE_CFG0: ATU_TYPE_CFG1;
 512         rk_pcie_map_cfg_atu(sc, 0, type);
 513
 514         switch (bytes) {
 515         case 1:
 516                 bus_poke_1(sc->axi_mem_res, addr, (uint8_t)val);
 517                 break;
 518         case 2:
 519                 bus_poke_2(sc->axi_mem_res, addr, (uint16_t)val);
 520                 break;
 521         case 4:
 522                 bus_poke_4(sc->axi_mem_res, addr, val);
 523                 break;
 524         default:
 525                 break;
 526         }
 527 }
 528
 529 #ifdef RK_PCIE_ENABLE_MSI
 530 static int
 531 rk_pcie_alloc_msi(device_t pci, device_t child, int count,
 532     int maxcount, int *irqs)
 533 {
 534         phandle_t msi_parent;
 535         int rv;
 536
 537         rv = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child),
 538             &msi_parent, NULL);
 539         if (rv != 0)
 540                 return (rv);
 541
 542         rv = intr_alloc_msi(pci, child, msi_parent, count, maxcount,irqs);
 543         return (rv);
 544 }
 545
 546 static int
 547 rk_pcie_release_msi(device_t pci, device_t child, int count, int *irqs)
 548 {
 549         phandle_t msi_parent;
 550         int rv;
 551
 552         rv = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child),
 553             &msi_parent, NULL);
 554         if (rv != 0)
 555                 return (rv);
 556         rv = intr_release_msi(pci, child, msi_parent, count, irqs);
 557         return (rv);
 558 }
 559 #endif
 560
 561 static int
 562 rk_pcie_map_msi(device_t pci, device_t child, int irq, uint64_t *addr,
 563     uint32_t *data)
 564 {
 565         phandle_t msi_parent;
 566         int rv;
 567
 568         rv = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child),
 569             &msi_parent, NULL);
 570         if (rv != 0)
 571                 return (rv);
 572         rv = intr_map_msi(pci, child, msi_parent, irq, addr, data);
 573         return (rv);
 574 }
 575
 576 #ifdef RK_PCIE_ENABLE_MSIX
 577 static int
 578 rk_pcie_alloc_msix(device_t pci, device_t child, int *irq)
 579 {
 580         phandle_t msi_parent;
 581         int rv;
 582
 583         rv = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child),
 584             &msi_parent, NULL);
 585         if (rv != 0)
 586                 return (rv);
 587         rv = intr_alloc_msix(pci, child, msi_parent, irq);
 588         return (rv);
 589 }
 590
 591 static int
 592 rk_pcie_release_msix(device_t pci, device_t child, int irq)
 593 {
 594         phandle_t msi_parent;
 595         int rv;
 596
 597         rv = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child),
 598             &msi_parent, NULL);
 599         if (rv != 0)
 600                 return (rv);
 601         rv = intr_release_msix(pci, child, msi_parent, irq);
 602         return (rv);
 603 }
 604 #endif
 605
 606 static int
 607 rk_pcie_get_id(device_t pci, device_t child, enum pci_id_type type,
 608     uintptr_t *id)
 609 {
 610         phandle_t node;
 611         int rv;
 612         uint32_t rid;
 613         uint16_t pci_rid;
 614
 615         if (type != PCI_ID_MSI)
 616                 return (pcib_get_id(pci, child, type, id));
 617
 618         node = ofw_bus_get_node(pci);
 619         pci_rid = pci_get_rid(child);
 620
 621         rv = ofw_bus_msimap(node, pci_rid, NULL, &rid);
 622         if (rv != 0)
 623                 return (rv);
 624
 625         *id = rid;
 626         return (0);
 627 }
 628
 629 static int
 630 rk_pcie_route_interrupt(device_t bus, device_t dev, int pin)
 631 {
 632         struct rk_pcie_softc *sc;
 633         u_int irq;
 634
 635         sc = device_get_softc(bus);
 636         irq = intr_map_clone_irq(rman_get_start(sc->legacy_irq_res));
 637         device_printf(bus, "route pin %d for device %d.%d to %u\n",
 638                     pin, pci_get_slot(dev), pci_get_function(dev), irq);
 639
 640         return (irq);
 641 }
 642
 643 /*-----------------------------------------------------------------------------
 644  *
 645  *  B U S  / D E V I C E   I N T E R F A C E
 646  */
 647 static int
 648 rk_pcie_parse_fdt_resources(struct rk_pcie_softc *sc)
 649 {
 650         int i, rv;
 651         char buf[16];
 652
 653         /* Regulators. All are optional. */
 654         rv = regulator_get_by_ofw_property(sc->dev, 0,
 655             "vpcie12v-supply", &sc->supply_12v);
 656         if (rv != 0 && rv != ENOENT) {
 657                 device_printf(sc->dev,"Cannot get 'vpcie12' regulator\n");
 658                 return (ENXIO);
 659         }
 660         rv = regulator_get_by_ofw_property(sc->dev, 0,
 661             "vpcie3v3-supply", &sc->supply_3v3);
 662         if (rv != 0 && rv != ENOENT) {
 663                 device_printf(sc->dev,"Cannot get 'vpcie3v3' regulator\n");
 664                 return (ENXIO);
 665         }
 666         rv = regulator_get_by_ofw_property(sc->dev, 0,
 667             "vpcie1v8-supply", &sc->supply_1v8);
 668         if (rv != 0 && rv != ENOENT) {
 669                 device_printf(sc->dev,"Cannot get 'vpcie1v8' regulator\n");
 670                 return (ENXIO);
 671         }
 672         rv = regulator_get_by_ofw_property(sc->dev, 0,
 673             "vpcie0v9-supply", &sc->supply_0v9);
 674         if (rv != 0 && rv != ENOENT) {
 675                 device_printf(sc->dev,"Cannot get 'vpcie0v9' regulator\n");
 676                 return (ENXIO);
 677         }
 678
 679         /* Resets. */
 680         rv = hwreset_get_by_ofw_name(sc->dev, 0, "core", &sc->hwreset_core);
 681         if (rv != 0) {
 682                 device_printf(sc->dev, "Cannot get 'core' reset\n");
 683                 return (ENXIO);
 684         }
 685         rv = hwreset_get_by_ofw_name(sc->dev, 0, "mgmt", &sc->hwreset_mgmt);
 686         if (rv != 0) {
 687                 device_printf(sc->dev, "Cannot get 'mgmt' reset\n");
 688                 return (ENXIO);
 689         }
 690         rv = hwreset_get_by_ofw_name(sc->dev, 0, "mgmt-sticky",
 691             &sc->hwreset_mgmt_sticky);
 692         if (rv != 0) {
 693                 device_printf(sc->dev, "Cannot get 'mgmt-sticky' reset\n");
 694                 return (ENXIO);
 695         }
 696         rv = hwreset_get_by_ofw_name(sc->dev, 0, "pipe", &sc->hwreset_pipe);
 697         if (rv != 0) {
 698                 device_printf(sc->dev, "Cannot get 'pipe' reset\n");
 699                 return (ENXIO);
 700         }
 701         rv = hwreset_get_by_ofw_name(sc->dev, 0, "pm", &sc->hwreset_pm);
 702         if (rv != 0) {
 703                 device_printf(sc->dev, "Cannot get 'pm' reset\n");
 704                 return (ENXIO);
 705         }
 706         rv = hwreset_get_by_ofw_name(sc->dev, 0, "aclk", &sc->hwreset_aclk);
 707         if (rv != 0) {
 708                 device_printf(sc->dev, "Cannot get 'aclk' reset\n");
 709                 return (ENXIO);
 710         }
 711         rv = hwreset_get_by_ofw_name(sc->dev, 0, "pclk", &sc->hwreset_pclk);
 712         if (rv != 0) {
 713                 device_printf(sc->dev, "Cannot get 'pclk' reset\n");
 714                 return (ENXIO);
 715         }
 716
 717         /* Clocks. */
 718         rv = clk_get_by_ofw_name(sc->dev, 0, "aclk", &sc->clk_aclk);
 719         if (rv != 0) {
 720                 device_printf(sc->dev, "Cannot get 'aclk' clock\n");
 721                 return (ENXIO);
 722         }
 723         rv = clk_get_by_ofw_name(sc->dev, 0, "aclk-perf", &sc->clk_aclk_perf);
 724         if (rv != 0) {
 725                 device_printf(sc->dev, "Cannot get 'aclk-perf' clock\n");
 726                 return (ENXIO);
 727         }
 728         rv = clk_get_by_ofw_name(sc->dev, 0, "hclk", &sc->clk_hclk);
 729         if (rv != 0) {
 730                 device_printf(sc->dev, "Cannot get 'hclk' clock\n");
 731                 return (ENXIO);
 732         }
 733         rv = clk_get_by_ofw_name(sc->dev, 0, "pm", &sc->clk_pm);
 734         if (rv != 0) {
 735                 device_printf(sc->dev, "Cannot get 'pm' clock\n");
 736                 return (ENXIO);
 737         }
 738
 739         /* Phys. */
 740         for (i = 0; i < MAX_LANES; i++ ) {
 741                 sprintf (buf, "pcie-phy-%d", i);
 742                 rv = phy_get_by_ofw_name(sc->dev, 0, buf, sc->phys + i);
 743                 if (rv != 0) {
 744                         device_printf(sc->dev, "Cannot get '%s' phy\n", buf);
 745                         return (ENXIO);
 746                 }
 747         }
 748
 749         /* GPIO for PERST#. Optional */
 750         rv = gpio_pin_get_by_ofw_property(sc->dev, sc->node, "ep-gpios",
 751             &sc->gpio_ep);
 752         if (rv != 0 && rv != ENOENT) {
 753                 device_printf(sc->dev, "Cannot get 'ep-gpios' gpio\n");
 754                 return (ENXIO);
 755         }
 756
 757         return (0);
 758 }
 759
 760 static int
 761 rk_pcie_enable_resources(struct rk_pcie_softc *sc)
 762 {
 763         int i, rv;
 764         uint32_t val;
 765
 766         /* Assert all resets */
 767         rv = hwreset_assert(sc->hwreset_pclk);
 768         if (rv != 0) {
 769                 device_printf(sc->dev, "Cannot assert 'pclk' reset\n");
 770                 return (rv);
 771         }
 772         rv = hwreset_assert(sc->hwreset_aclk);
 773         if (rv != 0) {
 774                 device_printf(sc->dev, "Cannot assert 'aclk' reset\n");
 775                 return (rv);
 776         }
 777         rv = hwreset_assert(sc->hwreset_pm);
 778         if (rv != 0) {
 779                 device_printf(sc->dev, "Cannot assert 'pm' reset\n");
 780                 return (rv);
 781         }
 782         rv = hwreset_assert(sc->hwreset_pipe);
 783         if (rv != 0) {
 784                 device_printf(sc->dev, "Cannot assert 'pipe' reset\n");
 785                 return (rv);
 786         }
 787         rv = hwreset_assert(sc->hwreset_mgmt_sticky);
 788         if (rv != 0) {
 789                 device_printf(sc->dev, "Cannot assert 'mgmt_sticky' reset\n");
 790                 return (rv);
 791         }
 792         rv = hwreset_assert(sc->hwreset_mgmt);
 793         if (rv != 0) {
 794                 device_printf(sc->dev, "Cannot assert 'hmgmt' reset\n");
 795                 return (rv);
 796         }
 797         rv = hwreset_assert(sc->hwreset_core);
 798         if (rv != 0) {
 799                 device_printf(sc->dev, "Cannot assert 'hcore' reset\n");
 800                 return (rv);
 801         }
 802         DELAY(10000);
 803
 804         /* Enable clockls */
 805         rv = clk_enable(sc->clk_aclk);
 806         if (rv != 0) {
 807                 device_printf(sc->dev, "Cannot enable 'aclk' clock\n");
 808                 return (rv);
 809         }
 810         rv = clk_enable(sc->clk_aclk_perf);
 811         if (rv != 0) {
 812                 device_printf(sc->dev, "Cannot enable 'aclk_perf' clock\n");
 813                 return (rv);
 814         }
 815         rv = clk_enable(sc->clk_hclk);
 816         if (rv != 0) {
 817                 device_printf(sc->dev, "Cannot enable 'hclk' clock\n");
 818                 return (rv);
 819         }
 820         rv = clk_enable(sc->clk_pm);
 821         if (rv != 0) {
 822                 device_printf(sc->dev, "Cannot enable 'pm' clock\n");
 823                 return (rv);
 824         }
 825
 826         /* Power up regulators */
 827         if (sc->supply_12v != NULL) {
 828                 rv = regulator_enable(sc->supply_12v);
 829                 if (rv != 0) {
 830                         device_printf(sc->dev,
 831                             "Cannot enable 'vpcie12' regulator\n");
 832                         return (rv);
 833                 }
 834         }
 835         if (sc->supply_3v3 != NULL) {
 836                 rv = regulator_enable(sc->supply_3v3);
 837                 if (rv != 0) {
 838                         device_printf(sc->dev,
 839                             "Cannot enable 'vpcie3v3' regulator\n");
 840                         return (rv);
 841                 }
 842         }
 843         if (sc->supply_1v8 != NULL) {
 844                 rv = regulator_enable(sc->supply_1v8);
 845                 if (rv != 0) {
 846                         device_printf(sc->dev,
 847                             "Cannot enable 'vpcie1v8' regulator\n");
 848                         return (rv);
 849                 }
 850         }
 851         if (sc->supply_0v9 != NULL) {
 852                 rv = regulator_enable(sc->supply_0v9);
 853                 if (rv != 0) {
 854                         device_printf(sc->dev,
 855                             "Cannot enable 'vpcie1v8' regulator\n");
 856                         return (rv);
 857                 }
 858         }
 859         DELAY(1000);
 860
 861         /* Deassert basic resets*/
 862         rv = hwreset_deassert(sc->hwreset_pm);
 863         if (rv != 0) {
 864                 device_printf(sc->dev, "Cannot deassert 'pm' reset\n");
 865                 return (rv);
 866         }
 867         rv = hwreset_deassert(sc->hwreset_aclk);
 868         if (rv != 0) {
 869                 device_printf(sc->dev, "Cannot deassert 'aclk' reset\n");
 870                 return (rv);
 871         }
 872         rv = hwreset_deassert(sc->hwreset_pclk);
 873         if (rv != 0) {
 874                 device_printf(sc->dev, "Cannot deassert 'pclk' reset\n");
 875                 return (rv);
 876         }
 877
 878         /* Set basic PCIe core mode (RC, lanes, gen1 or 2) */
 879         val  = STRAP_CONF_GEN_2 << 16 |
 880             (sc->link_is_gen2 ? STRAP_CONF_GEN_2: 0);
 881         val |= STRAP_CONF_MODE_RC << 16 | STRAP_CONF_MODE_RC;
 882         val |= STRAP_CONF_LANES(~0) << 16 | STRAP_CONF_LANES(sc->num_lanes);
 883         val |= STRAP_CONF_ARI_EN << 16 | STRAP_CONF_ARI_EN;
 884         val |= STRAP_CONF_CONF_EN << 16 | STRAP_CONF_CONF_EN;
 885         APB_WR4(sc, PCIE_CLIENT_BASIC_STRAP_CONF, val);
 886
 887         for (i = 0; i < MAX_LANES; i++) {
 888                 rv = phy_enable(sc->phys[i]);
 889                 if (rv != 0) {
 890                         device_printf(sc->dev, "Cannot enable phy %d\n", i);
 891                         return (rv);
 892                 }
 893         }
 894
 895         /* Deassert rest of resets - order is important ! */
 896         rv = hwreset_deassert(sc->hwreset_mgmt_sticky);
 897         if (rv != 0) {
 898                 device_printf(sc->dev, "Cannot deassert 'mgmt_sticky' reset\n");
 899                 return (rv);
 900         }
 901         rv = hwreset_deassert(sc->hwreset_core);
 902         if (rv != 0) {
 903                 device_printf(sc->dev, "Cannot deassert 'core' reset\n");
 904                 return (rv);
 905         }
 906         rv = hwreset_deassert(sc->hwreset_mgmt);
 907         if (rv != 0) {
 908                 device_printf(sc->dev, "Cannot deassert 'mgmt' reset\n");
 909                 return (rv);
 910         }
 911         rv = hwreset_deassert(sc->hwreset_pipe);
 912         if (rv != 0) {
 913                 device_printf(sc->dev, "Cannot deassert 'pipe' reset\n");
 914                 return (rv);
 915         }
 916         return (0);
 917 }
 918
 919 static int
 920 rk_pcie_setup_hw(struct rk_pcie_softc *sc)
 921 {
 922         uint32_t val;
 923         int i, rv;
 924
 925         /* Assert PERST# if defined */
 926         if (sc->gpio_ep != NULL) {
 927                 rv = gpio_pin_set_active(sc->gpio_ep, 0);
 928                 if (rv != 0) {
 929                         device_printf(sc->dev,
 930                             "Cannot clear 'gpio-ep' gpio\n");
 931                         return (rv);
 932                 }
 933         }
 934
 935         rv = rk_pcie_enable_resources(sc);
 936         if (rv != 0)
 937                 return(rv);
 938
 939         /* Fix wrong default value for transmited FTS for L0s exit */
 940         val = APB_RD4(sc, PCIE_CORE_CTRL1);
 941         val |= 0xFFFF << 8;
 942         APB_WR4(sc, PCIE_CORE_CTRL1, val);
 943
 944         /* Setup PCIE Link Status & Control register */
 945         val = APB_RD4(sc, PCIE_RC_CONFIG_LCS);
 946         val |= PCIEM_LINK_CTL_COMMON_CLOCK;
 947         APB_WR4(sc, PCIE_RC_CONFIG_LCS, val);
 948         val = APB_RD4(sc, PCIE_RC_CONFIG_LCS);
 949         val |= PCIEM_LINK_CTL_RCB;
 950         APB_WR4(sc, PCIE_RC_CONFIG_LCS, val);
 951
 952         /* Enable training for GEN1 */
 953         APB_WR4(sc, PCIE_CLIENT_BASIC_STRAP_CONF,
 954             STRAP_CONF_LINK_TRAIN_EN << 16 | STRAP_CONF_LINK_TRAIN_EN);
 955
 956         /* Deassert PERST# if defined */
 957         if (sc->gpio_ep != NULL) {
 958                 rv = gpio_pin_set_active(sc->gpio_ep, 1);
 959                 if (rv != 0) {
 960                         device_printf(sc->dev, "Cannot set 'gpio-ep' gpio\n");
 961                         return (rv);
 962                 }
 963         }
 964
 965         /* Wait for link */
 966         for (i = 500; i > 0; i--) {
 967                 val = APB_RD4(sc, PCIE_CLIENT_BASIC_STATUS1);
 968                 if (STATUS1_LINK_ST_GET(val) == STATUS1_LINK_ST_UP)
 969                         break;
 970                 DELAY(1000);
 971         }
 972         if (i <= 0) {
 973                 device_printf(sc->dev,
 974                     "Gen1 link training timeouted: 0x%08X.\n", val);
 975                 return (0);
 976         }
 977
 978         if (sc->link_is_gen2) {
 979                         val = APB_RD4(sc, PCIE_RC_CONFIG_LCS);
 980                         val |= PCIEM_LINK_CTL_RETRAIN_LINK;
 981                         APB_WR4(sc, PCIE_RC_CONFIG_LCS, val);
 982
 983                         /* Wait for link */
 984                         for (i = 500; i > 0; i--) {
 985                                 val = APB_RD4(sc, PCIE_CLIENT_BASIC_STATUS1);
 986                                 if (STATUS1_LINK_ST_GET(val) ==
 987                                     STATUS1_LINK_ST_UP)
 988                                         break;
 989                                 DELAY(1000);
 990                         }
 991                         if (i <= 0)
 992                                 device_printf(sc->dev, "Gen2 link training "
 993                                     "timeouted: 0x%08X.\n", val);
 994         }
 995
 996         val = APB_RD4(sc, PCIE_CORE_CTRL0);
 997         val = CORE_CTRL_LANES_GET(val);
 998         if (bootverbose)
 999                 device_printf(sc->dev, "Link width: %d\n", 1 << val);
1000
1001         return (0);
1002 }
1003
1004 static int
1005 rk_pcie_setup_sw(struct rk_pcie_softc *sc)
1006 {
1007         uint32_t val;
1008         int i, region;
1009
1010         pcib_bridge_init(sc->dev);
1011
1012         /* Setup config registers */
1013         APB_WR4(sc, PCIE_CORE_CONFIG_VENDOR, 0x1D87); /* Rockchip vendor ID*/
1014         PRIV_CFG_WR1(sc, PCIR_CLASS, PCIC_BRIDGE);
1015         PRIV_CFG_WR1(sc, PCIR_SUBCLASS, PCIS_BRIDGE_PCI);
1016         PRIV_CFG_WR1(sc, PCIR_PRIBUS_1, sc->root_bus);
1017         PRIV_CFG_WR1(sc, PCIR_SECBUS_1, sc->sub_bus);
1018         PRIV_CFG_WR1(sc, PCIR_SUBBUS_1, sc->bus_end);
1019         PRIV_CFG_WR2(sc, PCIR_COMMAND, PCIM_CMD_MEMEN |
1020            PCIM_CMD_BUSMASTEREN | PCIM_CMD_SERRESPEN);
1021
1022         /* Don't advertise L1 power substate */
1023         val = APB_RD4(sc, PCIE_RC_CONFIG_THP_CAP);
1024         val &= ~PCIE_RC_CONFIG_THP_CAP_NEXT_MASK;
1025         APB_WR4(sc, PCIE_RC_CONFIG_THP_CAP, val);
1026
1027         /* Don't advertise L0s */
1028         if (sc->no_l0s) {
1029                 val = APB_RD4(sc, PCIE_RC_CONFIG_LINK_CAP);
1030                 val &= ~PCIE_RC_CONFIG_THP_CAP_NEXT_MASK;
1031                 APB_WR4(sc, PCIE_RC_CONFIG_LINK_CAP_L0S, val);
1032         }
1033
1034         /*Adjust maximum payload size*/
1035         val = APB_RD4(sc, PCIE_RC_CONFIG_DCSR);
1036         val &= ~PCIE_RC_CONFIG_DCSR_MPS_MASK;
1037         val |= PCIE_RC_CONFIG_DCSR_MPS_128;
1038         APB_WR4(sc, PCIE_RC_CONFIG_DCSR, val);
1039
1040         /*
1041          * Prepare IB ATU
1042          * map whole address range in 1:1 mappings
1043          */
1044         rk_pcie_map_in_atu(sc, 2, 64 - 1, 0);
1045
1046         /* Prepare OB ATU */
1047         /* - region 0 (32 MB) is used for config access */
1048         region = 0;
1049         rk_pcie_map_out_atu(sc, region++, ATU_TYPE_CFG0, 25 - 1, 0);
1050
1051         /* - then map memory (by using 1MB regions */
1052         for (i = 0; i  < sc->mem_range.size / ATU_OB_REGION_SIZE; i++) {
1053                 rk_pcie_map_out_atu(sc,  region++, ATU_TYPE_MEM,
1054                     ATU_OB_REGION_SHIFT - 1,
1055                     sc->mem_range.pci + ATU_OB_REGION_SIZE * i);
1056         }
1057
1058         /* - IO space is next, one region typically*/
1059         for (i = 0; i  < sc->io_range.size / ATU_OB_REGION_SIZE; i++) {
1060                 rk_pcie_map_out_atu(sc, region++, ATU_TYPE_IO,
1061                     ATU_OB_REGION_SHIFT - 1,
1062                     sc->io_range.pci + ATU_OB_REGION_SIZE * i);
1063         }
1064         APB_WR4(sc, PCIE_CORE_RC_BAR_CONF, 0);
1065         return (0);
1066 }
1067
1068 static int
1069 rk_pcie_sys_irq(void *arg)
1070 {
1071         struct rk_pcie_softc *sc;
1072         uint32_t irq;
1073
1074         sc = (struct rk_pcie_softc *)arg;
1075         irq = APB_RD4(sc, PCIE_CLIENT_INT_STATUS);
1076         if (irq & PCIE_CLIENT_INT_LOCAL) {
1077                 irq = APB_RD4(sc, PCIE_CORE_INT_STATUS);
1078                 APB_WR4(sc, PCIE_CORE_INT_STATUS, irq);
1079                 APB_WR4(sc, PCIE_CLIENT_INT_STATUS, PCIE_CLIENT_INT_LOCAL);
1080
1081                 device_printf(sc->dev, "'sys' interrupt received: 0x%04X\n",
1082                     irq);
1083         }
1084
1085         return (FILTER_HANDLED);
1086 }
1087
1088 static int
1089 rk_pcie_client_irq(void *arg)
1090 {
1091         struct rk_pcie_softc *sc;
1092         uint32_t irq;
1093
1094         sc = (struct rk_pcie_softc *)arg;
1095         irq = APB_RD4(sc, PCIE_CLIENT_INT_STATUS);
1096         /* Clear causes handled by other interrups */
1097         irq &= ~PCIE_CLIENT_INT_LOCAL;
1098         irq &= ~PCIE_CLIENT_INT_LEGACY;
1099         APB_WR4(sc, PCIE_CLIENT_INT_STATUS, irq);
1100
1101         device_printf(sc->dev, "'client' interrupt received: 0x%04X\n", irq);
1102
1103         return (FILTER_HANDLED);
1104 }
1105
1106 static int
1107 rk_pcie_legacy_irq(void *arg)
1108 {
1109         struct rk_pcie_softc *sc;
1110         uint32_t irq;
1111
1112         sc = (struct rk_pcie_softc *)arg;
1113         irq = APB_RD4(sc, PCIE_CLIENT_INT_STATUS);
1114         irq &= PCIE_CLIENT_INT_LEGACY;
1115         APB_WR4(sc, PCIE_CLIENT_INT_STATUS, irq);
1116
1117         /* all legacy interrupt are shared, do nothing */
1118         return (FILTER_STRAY);
1119 }
1120
1121 static bus_dma_tag_t
1122 rk_pcie_get_dma_tag(device_t dev, device_t child)
1123 {
1124         struct rk_pcie_softc *sc;
1125
1126         sc = device_get_softc(dev);
1127         return (sc->dmat);
1128 }
1129
1130 static int
1131 rk_pcie_probe(device_t dev)
1132 {
1133
1134         if (!ofw_bus_status_okay(dev))
1135                 return (ENXIO);
1136
1137         if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
1138                 return (ENXIO);
1139
1140         device_set_desc(dev, "Rockchip PCIe controller");
1141         return (BUS_PROBE_DEFAULT);
1142 }
1143
1144 static int
1145 rk_pcie_attach(device_t dev)
1146 {       struct rk_pcie_softc *sc;
1147         uint32_t val;
1148         int rv, rid, max_speed;
1149
1150         sc = device_get_softc(dev);
1151         sc->dev = dev;
1152         sc->node = ofw_bus_get_node(dev);
1153
1154         mtx_init(&sc->mtx, "rk_pcie_mtx", NULL, MTX_DEF);
1155
1156         /* XXX Should not be this configurable ? */
1157         sc->bus_start = 0;
1158         sc->bus_end =  0x1F;
1159         sc->root_bus = sc->bus_start;
1160         sc->sub_bus = 1;
1161
1162         /* Read FDT properties */
1163         rv = rk_pcie_parse_fdt_resources(sc);
1164         if (rv != 0)
1165                 return (rv);
1166
1167         sc->coherent = OF_hasprop(sc->node, "dma-coherent");
1168         sc->no_l0s = OF_hasprop(sc->node, "aspm-no-l0s");
1169         rv = OF_getencprop(sc->node, "num-lanes", &sc->num_lanes,
1170             sizeof(sc->num_lanes));
1171         if (rv != sizeof(sc->num_lanes))
1172                 sc->num_lanes = 1;
1173         if (sc->num_lanes != 1 && sc->num_lanes != 2 && sc->num_lanes != 4) {
1174                 device_printf(dev,
1175                     "invalid number of lanes: %d\n",sc->num_lanes);
1176                 sc->num_lanes = 0;
1177                 rv = ENXIO;
1178                 goto out;
1179         }
1180
1181         rv = OF_getencprop(sc->node, "max-link-speed", &max_speed,
1182             sizeof(max_speed));
1183         if (rv != sizeof(max_speed) || max_speed != 1)
1184                 sc->link_is_gen2 = true;
1185         else
1186                 sc->link_is_gen2 = false;
1187
1188         rv = ofw_bus_find_string_index(sc->node, "reg-names", "axi-base", &rid);
1189         if (rv != 0) {
1190                 device_printf(dev, "Cannot get 'axi-base' memory\n");
1191                 rv = ENXIO;
1192                 goto out;
1193         }
1194         sc->axi_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
1195             RF_ACTIVE);
1196         if (sc->axi_mem_res == NULL) {
1197                 device_printf(dev, "Cannot allocate 'axi-base' (rid: %d)\n",
1198                     rid);
1199                 rv = ENXIO;
1200                 goto out;
1201         }
1202         rv = ofw_bus_find_string_index(sc->node, "reg-names", "apb-base", &rid);
1203         if (rv != 0) {
1204                 device_printf(dev, "Cannot get 'apb-base' memory\n");
1205                 rv = ENXIO;
1206                 goto out;
1207         }
1208         sc->apb_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
1209             RF_ACTIVE);
1210         if (sc->apb_mem_res == NULL) {
1211                 device_printf(dev, "Cannot allocate 'apb-base' (rid: %d)\n",
1212                     rid);
1213                 rv = ENXIO;
1214                 goto out;
1215         }
1216
1217         rv = ofw_bus_find_string_index(sc->node, "interrupt-names",
1218             "client", &rid);
1219         if (rv != 0) {
1220                 device_printf(dev, "Cannot get 'client' IRQ\n");
1221                 rv = ENXIO;
1222                 goto out;
1223         }
1224         sc->client_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
1225             RF_ACTIVE | RF_SHAREABLE);
1226         if (sc->client_irq_res == NULL) {
1227                 device_printf(dev, "Cannot allocate 'client' IRQ resource\n");
1228                 rv = ENXIO;
1229                 goto out;
1230         }
1231
1232         rv = ofw_bus_find_string_index(sc->node, "interrupt-names",
1233             "legacy", &rid);
1234         if (rv != 0) {
1235                 device_printf(dev, "Cannot get 'legacy' IRQ\n");
1236                 rv = ENXIO;
1237                 goto out;
1238         }
1239         sc->legacy_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
1240             RF_ACTIVE | RF_SHAREABLE);
1241         if (sc->legacy_irq_res == NULL) {
1242                 device_printf(dev, "Cannot allocate 'legacy' IRQ resource\n");
1243                 rv = ENXIO;
1244                 goto out;
1245         }
1246
1247         rv = ofw_bus_find_string_index(sc->node, "interrupt-names",
1248             "sys", &rid);
1249         if (rv != 0) {
1250                 device_printf(dev, "Cannot get 'sys' IRQ\n");
1251                 rv = ENXIO;
1252                 goto out;
1253         }
1254         sc->sys_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
1255             RF_ACTIVE | RF_SHAREABLE);
1256         if (sc->sys_irq_res == NULL) {
1257                 device_printf(dev, "Cannot allocate 'sys' IRQ resource\n");
1258                 rv = ENXIO;
1259                 goto out;
1260         }
1261
1262         if (bootverbose)
1263                 device_printf(dev, "Bus is%s cache-coherent\n",
1264                     sc->coherent ? "" : " not");
1265         rv = bus_dma_tag_create(bus_get_dma_tag(dev), /* parent */
1266             1, 0,                               /* alignment, bounds */
1267             BUS_SPACE_MAXADDR,                  /* lowaddr */
1268             BUS_SPACE_MAXADDR,                  /* highaddr */
1269             NULL, NULL,                         /* filter, filterarg */
1270             BUS_SPACE_MAXSIZE,                  /* maxsize */
1271             BUS_SPACE_UNRESTRICTED,             /* nsegments */
1272             BUS_SPACE_MAXSIZE,                  /* maxsegsize */
1273             sc->coherent ? BUS_DMA_COHERENT : 0, /* flags */
1274             NULL, NULL,                         /* lockfunc, lockarg */
1275             &sc->dmat);
1276         if (rv != 0)
1277                 goto out;
1278
1279         rv = ofw_pci_init(dev);
1280         if (rv != 0)
1281                 goto out;
1282
1283         rv = rk_pcie_decode_ranges(sc, sc->ofw_pci.sc_range,
1284             sc->ofw_pci.sc_nrange);
1285         if (rv != 0)
1286                 goto out;
1287         rv = rk_pcie_setup_hw(sc);
1288         if (rv != 0)
1289                 goto out;
1290
1291         rv = rk_pcie_setup_sw(sc);
1292         if (rv != 0)
1293                 goto out;
1294
1295         rv = bus_setup_intr(dev, sc->client_irq_res, INTR_TYPE_BIO | INTR_MPSAFE,
1296            rk_pcie_client_irq, NULL, sc, &sc->client_irq_cookie);
1297         if (rv != 0) {
1298                 device_printf(dev, "cannot setup client interrupt handler\n");
1299                 rv = ENXIO;
1300                 goto out;
1301         }
1302
1303         rv = bus_setup_intr(dev, sc->legacy_irq_res, INTR_TYPE_BIO | INTR_MPSAFE,
1304            rk_pcie_legacy_irq, NULL, sc, &sc->legacy_irq_cookie);
1305         if (rv != 0) {
1306                 device_printf(dev, "cannot setup client interrupt handler\n");
1307                 rv = ENXIO;
1308                 goto out;
1309         }
1310
1311         rv = bus_setup_intr(dev, sc->sys_irq_res, INTR_TYPE_BIO | INTR_MPSAFE,
1312            rk_pcie_sys_irq, NULL, sc, &sc->sys_irq_cookie);
1313         if (rv != 0) {
1314                 device_printf(dev, "cannot setup client interrupt handler\n");
1315                 rv = ENXIO;
1316                 goto out;
1317         }
1318
1319         /* Enable interrupts */
1320         val =
1321             PCIE_CLIENT_INT_CORR_ERR | PCIE_CLIENT_INT_NFATAL_ERR |
1322             PCIE_CLIENT_INT_FATAL_ERR | PCIE_CLIENT_INT_DPA |
1323             PCIE_CLIENT_INT_HOT_RST | PCIE_CLIENT_INT_MSG |
1324             PCIE_CLIENT_INT_LEGACY_DONE | PCIE_CLIENT_INT_INTA |
1325             PCIE_CLIENT_INT_INTB | PCIE_CLIENT_INT_INTC |
1326             PCIE_CLIENT_INT_INTD | PCIE_CLIENT_INT_PHY;
1327
1328         APB_WR4(sc, PCIE_CLIENT_INT_MASK, (val << 16) &  ~val);
1329
1330         val =
1331             PCIE_CORE_INT_PRFPE | PCIE_CORE_INT_CRFPE |
1332             PCIE_CORE_INT_RRPE | PCIE_CORE_INT_CRFO |
1333             PCIE_CORE_INT_RT | PCIE_CORE_INT_RTR |
1334             PCIE_CORE_INT_PE | PCIE_CORE_INT_MTR |
1335             PCIE_CORE_INT_UCR | PCIE_CORE_INT_FCE |
1336             PCIE_CORE_INT_CT | PCIE_CORE_INT_UTC |
1337             PCIE_CORE_INT_MMVC;
1338         APB_WR4(sc, PCIE_CORE_INT_MASK, ~(val));
1339
1340         val  = APB_RD4(sc, PCIE_RC_CONFIG_LCS);
1341         val |= PCIEM_LINK_CTL_LBMIE | PCIEM_LINK_CTL_LABIE;
1342         APB_WR4(sc, PCIE_RC_CONFIG_LCS, val);
1343
1344         DELAY(250000);
1345         device_add_child(dev, "pci", -1);
1346         return (bus_generic_attach(dev));
1347 out:
1348         /* XXX Cleanup */
1349         return (rv);
1350 }
1351
1352 static device_method_t rk_pcie_methods[] = {
1353         /* Device interface */
1354         DEVMETHOD(device_probe,         rk_pcie_probe),
1355         DEVMETHOD(device_attach,        rk_pcie_attach),
1356
1357         /* Bus interface */
1358         DEVMETHOD(bus_get_dma_tag,      rk_pcie_get_dma_tag),
1359
1360         /* pcib interface */
1361         DEVMETHOD(pcib_read_config,     rk_pcie_read_config),
1362         DEVMETHOD(pcib_write_config,    rk_pcie_write_config),
1363         DEVMETHOD(pcib_route_interrupt, rk_pcie_route_interrupt),
1364 #ifdef RK_PCIE_ENABLE_MSI
1365         DEVMETHOD(pcib_alloc_msi,       rk_pcie_alloc_msi),
1366         DEVMETHOD(pcib_release_msi,     rk_pcie_release_msi),
1367 #endif
1368 #ifdef RK_PCIE_ENABLE_MSIX
1369         DEVMETHOD(pcib_alloc_msix,      rk_pcie_alloc_msix),
1370         DEVMETHOD(pcib_release_msix,    rk_pcie_release_msix),
1371 #endif
1372         DEVMETHOD(pcib_map_msi,         rk_pcie_map_msi),
1373         DEVMETHOD(pcib_get_id,          rk_pcie_get_id),
1374
1375         /* OFW bus interface */
1376         DEVMETHOD(ofw_bus_get_compat,   ofw_bus_gen_get_compat),
1377         DEVMETHOD(ofw_bus_get_model,    ofw_bus_gen_get_model),
1378         DEVMETHOD(ofw_bus_get_name,     ofw_bus_gen_get_name),
1379         DEVMETHOD(ofw_bus_get_node,     ofw_bus_gen_get_node),
1380         DEVMETHOD(ofw_bus_get_type,     ofw_bus_gen_get_type),
1381
1382         DEVMETHOD_END
1383 };
1384
1385 DEFINE_CLASS_1(pcib, rk_pcie_driver, rk_pcie_methods,
1386     sizeof(struct rk_pcie_softc), ofw_pci_driver);
1387 static devclass_t rk_pcie_devclass;
1388 DRIVER_MODULE( rk_pcie, simplebus, rk_pcie_driver, rk_pcie_devclass,
1389     NULL, NULL);