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