drivers/pci/pci-rcar-gen3.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Renesas RCar Gen3 PCIEC driver
   4  *
   5  * Copyright (C) 2018-2019 Marek Vasut <marek.vasut@gmail.com>
   6  *
   7  * Based on Linux PCIe driver for Renesas R-Car SoCs
   8  *  Copyright (C) 2014 Renesas Electronics Europe Ltd
   9  *
  10  * Based on:
  11  *  arch/sh/drivers/pci/pcie-sh7786.c
  12  *  arch/sh/drivers/pci/ops-sh7786.c
  13  *  Copyright (C) 2009 - 2011  Paul Mundt
  14  *
  15  * Author: Phil Edworthy <phil.edworthy@renesas.com>
  16  */
  17
  18 #include <common.h>
  19 #include <asm/io.h>
  20 #include <clk.h>
  21 #include <dm.h>
  22 #include <errno.h>
  23 #include <pci.h>
  24 #include <wait_bit.h>
  25 #include <linux/bitops.h>
  26
  27 #define PCIECAR                 0x000010
  28 #define PCIECCTLR               0x000018
  29 #define  CONFIG_SEND_ENABLE     BIT(31)
  30 #define  TYPE0                  (0 << 8)
  31 #define  TYPE1                  BIT(8)
  32 #define PCIECDR                 0x000020
  33 #define PCIEMSR                 0x000028
  34 #define PCIEINTXR               0x000400
  35 #define PCIEPHYSR               0x0007f0
  36 #define  PHYRDY                 BIT(0)
  37 #define PCIEMSITXR              0x000840
  38
  39 /* Transfer control */
  40 #define PCIETCTLR               0x02000
  41 #define  CFINIT                 1
  42 #define PCIETSTR                0x02004
  43 #define  DATA_LINK_ACTIVE       1
  44 #define PCIEERRFR               0x02020
  45 #define  UNSUPPORTED_REQUEST    BIT(4)
  46 #define PCIEMSIFR               0x02044
  47 #define PCIEMSIALR              0x02048
  48 #define  MSIFE                  1
  49 #define PCIEMSIAUR              0x0204c
  50 #define PCIEMSIIER              0x02050
  51
  52 /* root port address */
  53 #define PCIEPRAR(x)             (0x02080 + ((x) * 0x4))
  54
  55 /* local address reg & mask */
  56 #define PCIELAR(x)              (0x02200 + ((x) * 0x20))
  57 #define PCIELAMR(x)             (0x02208 + ((x) * 0x20))
  58 #define  LAM_PREFETCH           BIT(3)
  59 #define  LAM_64BIT              BIT(2)
  60 #define  LAR_ENABLE             BIT(1)
  61
  62 /* PCIe address reg & mask */
  63 #define PCIEPALR(x)             (0x03400 + ((x) * 0x20))
  64 #define PCIEPAUR(x)             (0x03404 + ((x) * 0x20))
  65 #define PCIEPAMR(x)             (0x03408 + ((x) * 0x20))
  66 #define PCIEPTCTLR(x)           (0x0340c + ((x) * 0x20))
  67 #define  PAR_ENABLE             BIT(31)
  68 #define  IO_SPACE               BIT(8)
  69
  70 /* Configuration */
  71 #define PCICONF(x)              (0x010000 + ((x) * 0x4))
  72 #define PMCAP(x)                (0x010040 + ((x) * 0x4))
  73 #define EXPCAP(x)               (0x010070 + ((x) * 0x4))
  74 #define VCCAP(x)                (0x010100 + ((x) * 0x4))
  75
  76 /* link layer */
  77 #define IDSETR1                 0x011004
  78 #define TLCTLR                  0x011048
  79 #define MACSR                   0x011054
  80 #define  SPCHGFIN               BIT(4)
  81 #define  SPCHGFAIL              BIT(6)
  82 #define  SPCHGSUC               BIT(7)
  83 #define  LINK_SPEED             (0xf << 16)
  84 #define  LINK_SPEED_2_5GTS      (1 << 16)
  85 #define  LINK_SPEED_5_0GTS      (2 << 16)
  86 #define MACCTLR                 0x011058
  87 #define  SPEED_CHANGE           BIT(24)
  88 #define  SCRAMBLE_DISABLE       BIT(27)
  89 #define MACS2R                  0x011078
  90 #define MACCGSPSETR             0x011084
  91 #define  SPCNGRSN               BIT(31)
  92
  93 /* R-Car H1 PHY */
  94 #define H1_PCIEPHYADRR          0x04000c
  95 #define  WRITE_CMD              BIT(16)
  96 #define  PHY_ACK                BIT(24)
  97 #define  RATE_POS               12
  98 #define  LANE_POS               8
  99 #define  ADR_POS                0
 100 #define H1_PCIEPHYDOUTR         0x040014
 101
 102 /* R-Car Gen2 PHY */
 103 #define GEN2_PCIEPHYADDR        0x780
 104 #define GEN2_PCIEPHYDATA        0x784
 105 #define GEN2_PCIEPHYCTRL        0x78c
 106
 107 #define INT_PCI_MSI_NR          32
 108
 109 #define RCONF(x)                (PCICONF(0) + (x))
 110 #define RPMCAP(x)               (PMCAP(0) + (x))
 111 #define REXPCAP(x)              (EXPCAP(0) + (x))
 112 #define RVCCAP(x)               (VCCAP(0) + (x))
 113
 114 #define PCIE_CONF_BUS(b)        (((b) & 0xff) << 24)
 115 #define PCIE_CONF_DEV(d)        (((d) & 0x1f) << 19)
 116 #define PCIE_CONF_FUNC(f)       (((f) & 0x7) << 16)
 117
 118 #define RCAR_PCI_MAX_RESOURCES  4
 119 #define MAX_NR_INBOUND_MAPS     6
 120
 121 enum {
 122         RCAR_PCI_ACCESS_READ,
 123         RCAR_PCI_ACCESS_WRITE,
 124 };
 125
 126 struct rcar_gen3_pcie_priv {
 127         fdt_addr_t              regs;
 128 };
 129
 130 static void rcar_rmw32(struct udevice *dev, int where, u32 mask, u32 data)
 131 {
 132         struct rcar_gen3_pcie_priv *priv = dev_get_plat(dev);
 133         int shift = 8 * (where & 3);
 134
 135         clrsetbits_le32(priv->regs + (where & ~3),
 136                         mask << shift, data << shift);
 137 }
 138
 139 static u32 rcar_read_conf(const struct udevice *dev, int where)
 140 {
 141         struct rcar_gen3_pcie_priv *priv = dev_get_plat(dev);
 142         int shift = 8 * (where & 3);
 143
 144         return readl(priv->regs + (where & ~3)) >> shift;
 145 }
 146
 147 static int rcar_pcie_config_access(const struct udevice *udev,
 148                                    unsigned char access_type,
 149                                    pci_dev_t bdf, int where, ulong *data)
 150 {
 151         struct rcar_gen3_pcie_priv *priv = dev_get_plat(udev);
 152         u32 reg = where & ~3;
 153
 154         /* Clear errors */
 155         clrbits_le32(priv->regs + PCIEERRFR, 0);
 156
 157         /* Set the PIO address */
 158         writel((bdf << 8) | reg, priv->regs + PCIECAR);
 159
 160         /* Enable the configuration access */
 161         if (!PCI_BUS(bdf))
 162                 writel(CONFIG_SEND_ENABLE | TYPE0, priv->regs + PCIECCTLR);
 163         else
 164                 writel(CONFIG_SEND_ENABLE | TYPE1, priv->regs + PCIECCTLR);
 165
 166         /* Check for errors */
 167         if (readl(priv->regs + PCIEERRFR) & UNSUPPORTED_REQUEST)
 168                 return -ENODEV;
 169
 170         /* Check for master and target aborts */
 171         if (rcar_read_conf(udev, RCONF(PCI_STATUS)) &
 172                 (PCI_STATUS_REC_MASTER_ABORT | PCI_STATUS_REC_TARGET_ABORT))
 173                 return -ENODEV;
 174
 175         if (access_type == RCAR_PCI_ACCESS_READ)
 176                 *data = readl(priv->regs + PCIECDR);
 177         else
 178                 writel(*data, priv->regs + PCIECDR);
 179
 180         /* Disable the configuration access */
 181         writel(0, priv->regs + PCIECCTLR);
 182
 183         return 0;
 184 }
 185
 186 static int rcar_gen3_pcie_addr_valid(pci_dev_t d, uint where)
 187 {
 188         u32 slot;
 189
 190         if (PCI_FUNC(d))
 191                 return -EINVAL;
 192
 193         slot = PCI_DEV(d);
 194         if (slot != 1)
 195                 return -EINVAL;
 196
 197         return 0;
 198 }
 199
 200 static int rcar_gen3_pcie_read_config(const struct udevice *dev, pci_dev_t bdf,
 201                                       uint where, ulong *val,
 202                                       enum pci_size_t size)
 203 {
 204         ulong reg;
 205         int ret;
 206
 207         ret = rcar_gen3_pcie_addr_valid(bdf, where);
 208         if (ret) {
 209                 *val = pci_get_ff(size);
 210                 return 0;
 211         }
 212
 213         ret = rcar_pcie_config_access(dev, RCAR_PCI_ACCESS_READ,
 214                                       bdf, where, &reg);
 215         if (ret != 0)
 216                 reg = 0xffffffffUL;
 217
 218         *val = pci_conv_32_to_size(reg, where, size);
 219
 220         return ret;
 221 }
 222
 223 static int rcar_gen3_pcie_write_config(struct udevice *dev, pci_dev_t bdf,
 224                                        uint where, ulong val,
 225                                        enum pci_size_t size)
 226 {
 227         ulong data;
 228         int ret;
 229
 230         ret = rcar_gen3_pcie_addr_valid(bdf, where);
 231         if (ret)
 232                 return ret;
 233
 234         data = pci_conv_32_to_size(val, where, size);
 235
 236         ret = rcar_pcie_config_access(dev, RCAR_PCI_ACCESS_WRITE,
 237                                       bdf, where, &data);
 238
 239         return ret;
 240 }
 241
 242 static int rcar_gen3_pcie_wait_for_phyrdy(struct udevice *dev)
 243 {
 244         struct rcar_gen3_pcie_priv *priv = dev_get_plat(dev);
 245
 246         return wait_for_bit_le32((void *)priv->regs + PCIEPHYSR, PHYRDY,
 247                                  true, 50, false);
 248 }
 249
 250 static int rcar_gen3_pcie_wait_for_dl(struct udevice *dev)
 251 {
 252         struct rcar_gen3_pcie_priv *priv = dev_get_plat(dev);
 253
 254         return wait_for_bit_le32((void *)priv->regs + PCIETSTR,
 255                                  DATA_LINK_ACTIVE, true, 50, false);
 256 }
 257
 258 static int rcar_gen3_pcie_hw_init(struct udevice *dev)
 259 {
 260         struct rcar_gen3_pcie_priv *priv = dev_get_plat(dev);
 261         int ret;
 262
 263         /* Begin initialization */
 264         writel(0, priv->regs + PCIETCTLR);
 265
 266         /* Set mode */
 267         writel(1, priv->regs + PCIEMSR);
 268
 269         ret = rcar_gen3_pcie_wait_for_phyrdy(dev);
 270         if (ret)
 271                 return ret;
 272
 273         /*
 274          * Initial header for port config space is type 1, set the device
 275          * class to match. Hardware takes care of propagating the IDSETR
 276          * settings, so there is no need to bother with a quirk.
 277          */
 278         writel(PCI_CLASS_BRIDGE_PCI << 16, priv->regs + IDSETR1);
 279
 280         /*
 281          * Setup Secondary Bus Number & Subordinate Bus Number, even though
 282          * they aren't used, to avoid bridge being detected as broken.
 283          */
 284         rcar_rmw32(dev, RCONF(PCI_SECONDARY_BUS), 0xff, 1);
 285         rcar_rmw32(dev, RCONF(PCI_SUBORDINATE_BUS), 0xff, 1);
 286
 287         /* Initialize default capabilities. */
 288         rcar_rmw32(dev, REXPCAP(0), 0xff, PCI_CAP_ID_EXP);
 289         rcar_rmw32(dev, REXPCAP(PCI_EXP_FLAGS),
 290                    PCI_EXP_FLAGS_TYPE, PCI_EXP_TYPE_ROOT_PORT << 4);
 291         rcar_rmw32(dev, RCONF(PCI_HEADER_TYPE), 0x7f,
 292                    PCI_HEADER_TYPE_BRIDGE);
 293
 294         /* Enable data link layer active state reporting */
 295         rcar_rmw32(dev, REXPCAP(PCI_EXP_LNKCAP),
 296                    PCI_EXP_LNKCAP_DLLLARC, PCI_EXP_LNKCAP_DLLLARC);
 297
 298         /* Write out the physical slot number = 0 */
 299         rcar_rmw32(dev, REXPCAP(PCI_EXP_SLTCAP),
 300                    PCI_EXP_SLTCAP_PSN, 0);
 301
 302         /* Set the completion timer timeout to the maximum 50ms. */
 303         rcar_rmw32(dev, TLCTLR + 1, 0x3f, 50);
 304
 305         /* Terminate list of capabilities (Next Capability Offset=0) */
 306         rcar_rmw32(dev, RVCCAP(0), 0xfff00000, 0);
 307
 308         /* Finish initialization - establish a PCI Express link */
 309         writel(CFINIT, priv->regs + PCIETCTLR);
 310
 311         return rcar_gen3_pcie_wait_for_dl(dev);
 312 }
 313
 314 static int rcar_gen3_pcie_probe(struct udevice *dev)
 315 {
 316         struct rcar_gen3_pcie_priv *priv = dev_get_plat(dev);
 317         struct pci_controller *hose = dev_get_uclass_priv(dev);
 318         struct clk pci_clk;
 319         u32 mask;
 320         int i, cnt, ret;
 321
 322         ret = clk_get_by_index(dev, 0, &pci_clk);
 323         if (ret)
 324                 return ret;
 325
 326         ret = clk_enable(&pci_clk);
 327         if (ret)
 328                 return ret;
 329
 330         for (i = 0; i < hose->region_count; i++) {
 331                 if (hose->regions[i].flags != PCI_REGION_SYS_MEMORY)
 332                         continue;
 333
 334                 if (hose->regions[i].phys_start == 0)
 335                         continue;
 336
 337                 mask = (hose->regions[i].size - 1) & ~0xf;
 338                 mask |= LAR_ENABLE;
 339                 writel(hose->regions[i].phys_start, priv->regs + PCIEPRAR(0));
 340                 writel(hose->regions[i].phys_start, priv->regs + PCIELAR(0));
 341                 writel(mask, priv->regs + PCIELAMR(0));
 342                 break;
 343         }
 344
 345         writel(0, priv->regs + PCIEPRAR(4));
 346         writel(0, priv->regs + PCIELAR(4));
 347         writel(0, priv->regs + PCIELAMR(4));
 348
 349         ret = rcar_gen3_pcie_hw_init(dev);
 350         if (ret)
 351                 return ret;
 352
 353         for (i = 0, cnt = 0; i < hose->region_count; i++) {
 354                 if (hose->regions[i].flags == PCI_REGION_SYS_MEMORY)
 355                         continue;
 356
 357                 writel(0, priv->regs + PCIEPTCTLR(cnt));
 358                 writel((hose->regions[i].size - 1) & ~0x7f,
 359                        priv->regs + PCIEPAMR(cnt));
 360                 writel(upper_32_bits(hose->regions[i].phys_start),
 361                        priv->regs + PCIEPAUR(cnt));
 362                 writel(lower_32_bits(hose->regions[i].phys_start),
 363                        priv->regs + PCIEPALR(cnt));
 364                 mask = PAR_ENABLE;
 365                 if (hose->regions[i].flags == PCI_REGION_IO)
 366                         mask |= IO_SPACE;
 367                 writel(mask, priv->regs + PCIEPTCTLR(cnt));
 368
 369                 cnt++;
 370         }
 371
 372         return 0;
 373 }
 374
 375 static int rcar_gen3_pcie_of_to_plat(struct udevice *dev)
 376 {
 377         struct rcar_gen3_pcie_priv *priv = dev_get_plat(dev);
 378
 379         priv->regs = devfdt_get_addr_index(dev, 0);
 380         if (!priv->regs)
 381                 return -EINVAL;
 382
 383         return 0;
 384 }
 385
 386 static const struct dm_pci_ops rcar_gen3_pcie_ops = {
 387         .read_config    = rcar_gen3_pcie_read_config,
 388         .write_config   = rcar_gen3_pcie_write_config,
 389 };
 390
 391 static const struct udevice_id rcar_gen3_pcie_ids[] = {
 392         { .compatible = "renesas,pcie-rcar-gen3" },
 393         { }
 394 };
 395
 396 U_BOOT_DRIVER(rcar_gen3_pcie) = {
 397         .name                   = "rcar_gen3_pcie",
 398         .id                     = UCLASS_PCI,
 399         .of_match               = rcar_gen3_pcie_ids,
 400         .ops                    = &rcar_gen3_pcie_ops,
 401         .probe                  = rcar_gen3_pcie_probe,
 402         .of_to_plat     = rcar_gen3_pcie_of_to_plat,
 403         .plat_auto      = sizeof(struct rcar_gen3_pcie_priv),
 404 };