drivers/pci/controller/pcie-iproc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2014 Hauke Mehrtens <hauke@hauke-m.de>
   4  * Copyright (C) 2015 Broadcom Corporation
   5  */
   6
   7 #include <linux/kernel.h>
   8 #include <linux/pci.h>
   9 #include <linux/msi.h>
  10 #include <linux/clk.h>
  11 #include <linux/module.h>
  12 #include <linux/mbus.h>
  13 #include <linux/slab.h>
  14 #include <linux/delay.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/irqchip/arm-gic-v3.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/of_address.h>
  19 #include <linux/of_pci.h>
  20 #include <linux/of_irq.h>
  21 #include <linux/of_platform.h>
  22 #include <linux/phy/phy.h>
  23
  24 #include "pcie-iproc.h"
  25
  26 #define EP_PERST_SOURCE_SELECT_SHIFT    2
  27 #define EP_PERST_SOURCE_SELECT          BIT(EP_PERST_SOURCE_SELECT_SHIFT)
  28 #define EP_MODE_SURVIVE_PERST_SHIFT     1
  29 #define EP_MODE_SURVIVE_PERST           BIT(EP_MODE_SURVIVE_PERST_SHIFT)
  30 #define RC_PCIE_RST_OUTPUT_SHIFT        0
  31 #define RC_PCIE_RST_OUTPUT              BIT(RC_PCIE_RST_OUTPUT_SHIFT)
  32 #define PAXC_RESET_MASK                 0x7f
  33
  34 #define GIC_V3_CFG_SHIFT                0
  35 #define GIC_V3_CFG                      BIT(GIC_V3_CFG_SHIFT)
  36
  37 #define MSI_ENABLE_CFG_SHIFT            0
  38 #define MSI_ENABLE_CFG                  BIT(MSI_ENABLE_CFG_SHIFT)
  39
  40 #define CFG_IND_ADDR_MASK               0x00001ffc
  41
  42 #define CFG_ADDR_BUS_NUM_SHIFT          20
  43 #define CFG_ADDR_BUS_NUM_MASK           0x0ff00000
  44 #define CFG_ADDR_DEV_NUM_SHIFT          15
  45 #define CFG_ADDR_DEV_NUM_MASK           0x000f8000
  46 #define CFG_ADDR_FUNC_NUM_SHIFT         12
  47 #define CFG_ADDR_FUNC_NUM_MASK          0x00007000
  48 #define CFG_ADDR_REG_NUM_SHIFT          2
  49 #define CFG_ADDR_REG_NUM_MASK           0x00000ffc
  50 #define CFG_ADDR_CFG_TYPE_SHIFT         0
  51 #define CFG_ADDR_CFG_TYPE_MASK          0x00000003
  52
  53 #define SYS_RC_INTX_MASK                0xf
  54
  55 #define PCIE_PHYLINKUP_SHIFT            3
  56 #define PCIE_PHYLINKUP                  BIT(PCIE_PHYLINKUP_SHIFT)
  57 #define PCIE_DL_ACTIVE_SHIFT            2
  58 #define PCIE_DL_ACTIVE                  BIT(PCIE_DL_ACTIVE_SHIFT)
  59
  60 #define APB_ERR_EN_SHIFT                0
  61 #define APB_ERR_EN                      BIT(APB_ERR_EN_SHIFT)
  62
  63 #define CFG_RETRY_STATUS                0xffff0001
  64 #define CFG_RETRY_STATUS_TIMEOUT_US     500000 /* 500 milliseconds */
  65
  66 /* derive the enum index of the outbound/inbound mapping registers */
  67 #define MAP_REG(base_reg, index)        ((base_reg) + (index) * 2)
  68
  69 /*
  70  * Maximum number of outbound mapping window sizes that can be supported by any
  71  * OARR/OMAP mapping pair
  72  */
  73 #define MAX_NUM_OB_WINDOW_SIZES         4
  74
  75 #define OARR_VALID_SHIFT                0
  76 #define OARR_VALID                      BIT(OARR_VALID_SHIFT)
  77 #define OARR_SIZE_CFG_SHIFT             1
  78
  79 /*
  80  * Maximum number of inbound mapping region sizes that can be supported by an
  81  * IARR
  82  */
  83 #define MAX_NUM_IB_REGION_SIZES         9
  84
  85 #define IMAP_VALID_SHIFT                0
  86 #define IMAP_VALID                      BIT(IMAP_VALID_SHIFT)
  87
  88 #define IPROC_PCI_PM_CAP                0x48
  89 #define IPROC_PCI_PM_CAP_MASK           0xffff
  90 #define IPROC_PCI_EXP_CAP               0xac
  91
  92 #define IPROC_PCIE_REG_INVALID          0xffff
  93
  94 /**
  95  * iProc PCIe outbound mapping controller specific parameters
  96  *
  97  * @window_sizes: list of supported outbound mapping window sizes in MB
  98  * @nr_sizes: number of supported outbound mapping window sizes
  99  */
 100 struct iproc_pcie_ob_map {
 101         resource_size_t window_sizes[MAX_NUM_OB_WINDOW_SIZES];
 102         unsigned int nr_sizes;
 103 };
 104
 105 static const struct iproc_pcie_ob_map paxb_ob_map[] = {
 106         {
 107                 /* OARR0/OMAP0 */
 108                 .window_sizes = { 128, 256 },
 109                 .nr_sizes = 2,
 110         },
 111         {
 112                 /* OARR1/OMAP1 */
 113                 .window_sizes = { 128, 256 },
 114                 .nr_sizes = 2,
 115         },
 116 };
 117
 118 static const struct iproc_pcie_ob_map paxb_v2_ob_map[] = {
 119         {
 120                 /* OARR0/OMAP0 */
 121                 .window_sizes = { 128, 256 },
 122                 .nr_sizes = 2,
 123         },
 124         {
 125                 /* OARR1/OMAP1 */
 126                 .window_sizes = { 128, 256 },
 127                 .nr_sizes = 2,
 128         },
 129         {
 130                 /* OARR2/OMAP2 */
 131                 .window_sizes = { 128, 256, 512, 1024 },
 132                 .nr_sizes = 4,
 133         },
 134         {
 135                 /* OARR3/OMAP3 */
 136                 .window_sizes = { 128, 256, 512, 1024 },
 137                 .nr_sizes = 4,
 138         },
 139 };
 140
 141 /**
 142  * iProc PCIe inbound mapping type
 143  */
 144 enum iproc_pcie_ib_map_type {
 145         /* for DDR memory */
 146         IPROC_PCIE_IB_MAP_MEM = 0,
 147
 148         /* for device I/O memory */
 149         IPROC_PCIE_IB_MAP_IO,
 150
 151         /* invalid or unused */
 152         IPROC_PCIE_IB_MAP_INVALID
 153 };
 154
 155 /**
 156  * iProc PCIe inbound mapping controller specific parameters
 157  *
 158  * @type: inbound mapping region type
 159  * @size_unit: inbound mapping region size unit, could be SZ_1K, SZ_1M, or
 160  * SZ_1G
 161  * @region_sizes: list of supported inbound mapping region sizes in KB, MB, or
 162  * GB, depedning on the size unit
 163  * @nr_sizes: number of supported inbound mapping region sizes
 164  * @nr_windows: number of supported inbound mapping windows for the region
 165  * @imap_addr_offset: register offset between the upper and lower 32-bit
 166  * IMAP address registers
 167  * @imap_window_offset: register offset between each IMAP window
 168  */
 169 struct iproc_pcie_ib_map {
 170         enum iproc_pcie_ib_map_type type;
 171         unsigned int size_unit;
 172         resource_size_t region_sizes[MAX_NUM_IB_REGION_SIZES];
 173         unsigned int nr_sizes;
 174         unsigned int nr_windows;
 175         u16 imap_addr_offset;
 176         u16 imap_window_offset;
 177 };
 178
 179 static const struct iproc_pcie_ib_map paxb_v2_ib_map[] = {
 180         {
 181                 /* IARR0/IMAP0 */
 182                 .type = IPROC_PCIE_IB_MAP_IO,
 183                 .size_unit = SZ_1K,
 184                 .region_sizes = { 32 },
 185                 .nr_sizes = 1,
 186                 .nr_windows = 8,
 187                 .imap_addr_offset = 0x40,
 188                 .imap_window_offset = 0x4,
 189         },
 190         {
 191                 /* IARR1/IMAP1 (currently unused) */
 192                 .type = IPROC_PCIE_IB_MAP_INVALID,
 193         },
 194         {
 195                 /* IARR2/IMAP2 */
 196                 .type = IPROC_PCIE_IB_MAP_MEM,
 197                 .size_unit = SZ_1M,
 198                 .region_sizes = { 64, 128, 256, 512, 1024, 2048, 4096, 8192,
 199                                   16384 },
 200                 .nr_sizes = 9,
 201                 .nr_windows = 1,
 202                 .imap_addr_offset = 0x4,
 203                 .imap_window_offset = 0x8,
 204         },
 205         {
 206                 /* IARR3/IMAP3 */
 207                 .type = IPROC_PCIE_IB_MAP_MEM,
 208                 .size_unit = SZ_1G,
 209                 .region_sizes = { 1, 2, 4, 8, 16, 32 },
 210                 .nr_sizes = 6,
 211                 .nr_windows = 8,
 212                 .imap_addr_offset = 0x4,
 213                 .imap_window_offset = 0x8,
 214         },
 215         {
 216                 /* IARR4/IMAP4 */
 217                 .type = IPROC_PCIE_IB_MAP_MEM,
 218                 .size_unit = SZ_1G,
 219                 .region_sizes = { 32, 64, 128, 256, 512 },
 220                 .nr_sizes = 5,
 221                 .nr_windows = 8,
 222                 .imap_addr_offset = 0x4,
 223                 .imap_window_offset = 0x8,
 224         },
 225 };
 226
 227 /*
 228  * iProc PCIe host registers
 229  */
 230 enum iproc_pcie_reg {
 231         /* clock/reset signal control */
 232         IPROC_PCIE_CLK_CTRL = 0,
 233
 234         /*
 235          * To allow MSI to be steered to an external MSI controller (e.g., ARM
 236          * GICv3 ITS)
 237          */
 238         IPROC_PCIE_MSI_GIC_MODE,
 239
 240         /*
 241          * IPROC_PCIE_MSI_BASE_ADDR and IPROC_PCIE_MSI_WINDOW_SIZE define the
 242          * window where the MSI posted writes are written, for the writes to be
 243          * interpreted as MSI writes.
 244          */
 245         IPROC_PCIE_MSI_BASE_ADDR,
 246         IPROC_PCIE_MSI_WINDOW_SIZE,
 247
 248         /*
 249          * To hold the address of the register where the MSI writes are
 250          * programed.  When ARM GICv3 ITS is used, this should be programmed
 251          * with the address of the GITS_TRANSLATER register.
 252          */
 253         IPROC_PCIE_MSI_ADDR_LO,
 254         IPROC_PCIE_MSI_ADDR_HI,
 255
 256         /* enable MSI */
 257         IPROC_PCIE_MSI_EN_CFG,
 258
 259         /* allow access to root complex configuration space */
 260         IPROC_PCIE_CFG_IND_ADDR,
 261         IPROC_PCIE_CFG_IND_DATA,
 262
 263         /* allow access to device configuration space */
 264         IPROC_PCIE_CFG_ADDR,
 265         IPROC_PCIE_CFG_DATA,
 266
 267         /* enable INTx */
 268         IPROC_PCIE_INTX_EN,
 269
 270         /* outbound address mapping */
 271         IPROC_PCIE_OARR0,
 272         IPROC_PCIE_OMAP0,
 273         IPROC_PCIE_OARR1,
 274         IPROC_PCIE_OMAP1,
 275         IPROC_PCIE_OARR2,
 276         IPROC_PCIE_OMAP2,
 277         IPROC_PCIE_OARR3,
 278         IPROC_PCIE_OMAP3,
 279
 280         /* inbound address mapping */
 281         IPROC_PCIE_IARR0,
 282         IPROC_PCIE_IMAP0,
 283         IPROC_PCIE_IARR1,
 284         IPROC_PCIE_IMAP1,
 285         IPROC_PCIE_IARR2,
 286         IPROC_PCIE_IMAP2,
 287         IPROC_PCIE_IARR3,
 288         IPROC_PCIE_IMAP3,
 289         IPROC_PCIE_IARR4,
 290         IPROC_PCIE_IMAP4,
 291
 292         /* link status */
 293         IPROC_PCIE_LINK_STATUS,
 294
 295         /* enable APB error for unsupported requests */
 296         IPROC_PCIE_APB_ERR_EN,
 297
 298         /* total number of core registers */
 299         IPROC_PCIE_MAX_NUM_REG,
 300 };
 301
 302 /* iProc PCIe PAXB BCMA registers */
 303 static const u16 iproc_pcie_reg_paxb_bcma[IPROC_PCIE_MAX_NUM_REG] = {
 304         [IPROC_PCIE_CLK_CTRL]           = 0x000,
 305         [IPROC_PCIE_CFG_IND_ADDR]       = 0x120,
 306         [IPROC_PCIE_CFG_IND_DATA]       = 0x124,
 307         [IPROC_PCIE_CFG_ADDR]           = 0x1f8,
 308         [IPROC_PCIE_CFG_DATA]           = 0x1fc,
 309         [IPROC_PCIE_INTX_EN]            = 0x330,
 310         [IPROC_PCIE_LINK_STATUS]        = 0xf0c,
 311 };
 312
 313 /* iProc PCIe PAXB registers */
 314 static const u16 iproc_pcie_reg_paxb[IPROC_PCIE_MAX_NUM_REG] = {
 315         [IPROC_PCIE_CLK_CTRL]           = 0x000,
 316         [IPROC_PCIE_CFG_IND_ADDR]       = 0x120,
 317         [IPROC_PCIE_CFG_IND_DATA]       = 0x124,
 318         [IPROC_PCIE_CFG_ADDR]           = 0x1f8,
 319         [IPROC_PCIE_CFG_DATA]           = 0x1fc,
 320         [IPROC_PCIE_INTX_EN]            = 0x330,
 321         [IPROC_PCIE_OARR0]              = 0xd20,
 322         [IPROC_PCIE_OMAP0]              = 0xd40,
 323         [IPROC_PCIE_OARR1]              = 0xd28,
 324         [IPROC_PCIE_OMAP1]              = 0xd48,
 325         [IPROC_PCIE_LINK_STATUS]        = 0xf0c,
 326         [IPROC_PCIE_APB_ERR_EN]         = 0xf40,
 327 };
 328
 329 /* iProc PCIe PAXB v2 registers */
 330 static const u16 iproc_pcie_reg_paxb_v2[IPROC_PCIE_MAX_NUM_REG] = {
 331         [IPROC_PCIE_CLK_CTRL]           = 0x000,
 332         [IPROC_PCIE_CFG_IND_ADDR]       = 0x120,
 333         [IPROC_PCIE_CFG_IND_DATA]       = 0x124,
 334         [IPROC_PCIE_CFG_ADDR]           = 0x1f8,
 335         [IPROC_PCIE_CFG_DATA]           = 0x1fc,
 336         [IPROC_PCIE_INTX_EN]            = 0x330,
 337         [IPROC_PCIE_OARR0]              = 0xd20,
 338         [IPROC_PCIE_OMAP0]              = 0xd40,
 339         [IPROC_PCIE_OARR1]              = 0xd28,
 340         [IPROC_PCIE_OMAP1]              = 0xd48,
 341         [IPROC_PCIE_OARR2]              = 0xd60,
 342         [IPROC_PCIE_OMAP2]              = 0xd68,
 343         [IPROC_PCIE_OARR3]              = 0xdf0,
 344         [IPROC_PCIE_OMAP3]              = 0xdf8,
 345         [IPROC_PCIE_IARR0]              = 0xd00,
 346         [IPROC_PCIE_IMAP0]              = 0xc00,
 347         [IPROC_PCIE_IARR2]              = 0xd10,
 348         [IPROC_PCIE_IMAP2]              = 0xcc0,
 349         [IPROC_PCIE_IARR3]              = 0xe00,
 350         [IPROC_PCIE_IMAP3]              = 0xe08,
 351         [IPROC_PCIE_IARR4]              = 0xe68,
 352         [IPROC_PCIE_IMAP4]              = 0xe70,
 353         [IPROC_PCIE_LINK_STATUS]        = 0xf0c,
 354         [IPROC_PCIE_APB_ERR_EN]         = 0xf40,
 355 };
 356
 357 /* iProc PCIe PAXC v1 registers */
 358 static const u16 iproc_pcie_reg_paxc[IPROC_PCIE_MAX_NUM_REG] = {
 359         [IPROC_PCIE_CLK_CTRL]           = 0x000,
 360         [IPROC_PCIE_CFG_IND_ADDR]       = 0x1f0,
 361         [IPROC_PCIE_CFG_IND_DATA]       = 0x1f4,
 362         [IPROC_PCIE_CFG_ADDR]           = 0x1f8,
 363         [IPROC_PCIE_CFG_DATA]           = 0x1fc,
 364 };
 365
 366 /* iProc PCIe PAXC v2 registers */
 367 static const u16 iproc_pcie_reg_paxc_v2[IPROC_PCIE_MAX_NUM_REG] = {
 368         [IPROC_PCIE_MSI_GIC_MODE]       = 0x050,
 369         [IPROC_PCIE_MSI_BASE_ADDR]      = 0x074,
 370         [IPROC_PCIE_MSI_WINDOW_SIZE]    = 0x078,
 371         [IPROC_PCIE_MSI_ADDR_LO]        = 0x07c,
 372         [IPROC_PCIE_MSI_ADDR_HI]        = 0x080,
 373         [IPROC_PCIE_MSI_EN_CFG]         = 0x09c,
 374         [IPROC_PCIE_CFG_IND_ADDR]       = 0x1f0,
 375         [IPROC_PCIE_CFG_IND_DATA]       = 0x1f4,
 376         [IPROC_PCIE_CFG_ADDR]           = 0x1f8,
 377         [IPROC_PCIE_CFG_DATA]           = 0x1fc,
 378 };
 379
 380 /*
 381  * List of device IDs of controllers that have corrupted capability list that
 382  * require SW fixup
 383  */
 384 static const u16 iproc_pcie_corrupt_cap_did[] = {
 385         0x16cd,
 386         0x16f0,
 387         0xd802,
 388         0xd804
 389 };
 390
 391 static inline struct iproc_pcie *iproc_data(struct pci_bus *bus)
 392 {
 393         struct iproc_pcie *pcie = bus->sysdata;
 394         return pcie;
 395 }
 396
 397 static inline bool iproc_pcie_reg_is_invalid(u16 reg_offset)
 398 {
 399         return !!(reg_offset == IPROC_PCIE_REG_INVALID);
 400 }
 401
 402 static inline u16 iproc_pcie_reg_offset(struct iproc_pcie *pcie,
 403                                         enum iproc_pcie_reg reg)
 404 {
 405         return pcie->reg_offsets[reg];
 406 }
 407
 408 static inline u32 iproc_pcie_read_reg(struct iproc_pcie *pcie,
 409                                       enum iproc_pcie_reg reg)
 410 {
 411         u16 offset = iproc_pcie_reg_offset(pcie, reg);
 412
 413         if (iproc_pcie_reg_is_invalid(offset))
 414                 return 0;
 415
 416         return readl(pcie->base + offset);
 417 }
 418
 419 static inline void iproc_pcie_write_reg(struct iproc_pcie *pcie,
 420                                         enum iproc_pcie_reg reg, u32 val)
 421 {
 422         u16 offset = iproc_pcie_reg_offset(pcie, reg);
 423
 424         if (iproc_pcie_reg_is_invalid(offset))
 425                 return;
 426
 427         writel(val, pcie->base + offset);
 428 }
 429
 430 /**
 431  * APB error forwarding can be disabled during access of configuration
 432  * registers of the endpoint device, to prevent unsupported requests
 433  * (typically seen during enumeration with multi-function devices) from
 434  * triggering a system exception.
 435  */
 436 static inline void iproc_pcie_apb_err_disable(struct pci_bus *bus,
 437                                               bool disable)
 438 {
 439         struct iproc_pcie *pcie = iproc_data(bus);
 440         u32 val;
 441
 442         if (bus->number && pcie->has_apb_err_disable) {
 443                 val = iproc_pcie_read_reg(pcie, IPROC_PCIE_APB_ERR_EN);
 444                 if (disable)
 445                         val &= ~APB_ERR_EN;
 446                 else
 447                         val |= APB_ERR_EN;
 448                 iproc_pcie_write_reg(pcie, IPROC_PCIE_APB_ERR_EN, val);
 449         }
 450 }
 451
 452 static void __iomem *iproc_pcie_map_ep_cfg_reg(struct iproc_pcie *pcie,
 453                                                unsigned int busno,
 454                                                unsigned int slot,
 455                                                unsigned int fn,
 456                                                int where)
 457 {
 458         u16 offset;
 459         u32 val;
 460
 461         /* EP device access */
 462         val = (busno << CFG_ADDR_BUS_NUM_SHIFT) |
 463                 (slot << CFG_ADDR_DEV_NUM_SHIFT) |
 464                 (fn << CFG_ADDR_FUNC_NUM_SHIFT) |
 465                 (where & CFG_ADDR_REG_NUM_MASK) |
 466                 (1 & CFG_ADDR_CFG_TYPE_MASK);
 467
 468         iproc_pcie_write_reg(pcie, IPROC_PCIE_CFG_ADDR, val);
 469         offset = iproc_pcie_reg_offset(pcie, IPROC_PCIE_CFG_DATA);
 470
 471         if (iproc_pcie_reg_is_invalid(offset))
 472                 return NULL;
 473
 474         return (pcie->base + offset);
 475 }
 476
 477 static unsigned int iproc_pcie_cfg_retry(void __iomem *cfg_data_p)
 478 {
 479         int timeout = CFG_RETRY_STATUS_TIMEOUT_US;
 480         unsigned int data;
 481
 482         /*
 483          * As per PCIe spec r3.1, sec 2.3.2, CRS Software Visibility only
 484          * affects config reads of the Vendor ID.  For config writes or any
 485          * other config reads, the Root may automatically reissue the
 486          * configuration request again as a new request.
 487          *
 488          * For config reads, this hardware returns CFG_RETRY_STATUS data
 489          * when it receives a CRS completion, regardless of the address of
 490          * the read or the CRS Software Visibility Enable bit.  As a
 491          * partial workaround for this, we retry in software any read that
 492          * returns CFG_RETRY_STATUS.
 493          *
 494          * Note that a non-Vendor ID config register may have a value of
 495          * CFG_RETRY_STATUS.  If we read that, we can't distinguish it from
 496          * a CRS completion, so we will incorrectly retry the read and
 497          * eventually return the wrong data (0xffffffff).
 498          */
 499         data = readl(cfg_data_p);
 500         while (data == CFG_RETRY_STATUS && timeout--) {
 501                 udelay(1);
 502                 data = readl(cfg_data_p);
 503         }
 504
 505         if (data == CFG_RETRY_STATUS)
 506                 data = 0xffffffff;
 507
 508         return data;
 509 }
 510
 511 static void iproc_pcie_fix_cap(struct iproc_pcie *pcie, int where, u32 *val)
 512 {
 513         u32 i, dev_id;
 514
 515         switch (where & ~0x3) {
 516         case PCI_VENDOR_ID:
 517                 dev_id = *val >> 16;
 518
 519                 /*
 520                  * Activate fixup for those controllers that have corrupted
 521                  * capability list registers
 522                  */
 523                 for (i = 0; i < ARRAY_SIZE(iproc_pcie_corrupt_cap_did); i++)
 524                         if (dev_id == iproc_pcie_corrupt_cap_did[i])
 525                                 pcie->fix_paxc_cap = true;
 526                 break;
 527
 528         case IPROC_PCI_PM_CAP:
 529                 if (pcie->fix_paxc_cap) {
 530                         /* advertise PM, force next capability to PCIe */
 531                         *val &= ~IPROC_PCI_PM_CAP_MASK;
 532                         *val |= IPROC_PCI_EXP_CAP << 8 | PCI_CAP_ID_PM;
 533                 }
 534                 break;
 535
 536         case IPROC_PCI_EXP_CAP:
 537                 if (pcie->fix_paxc_cap) {
 538                         /* advertise root port, version 2, terminate here */
 539                         *val = (PCI_EXP_TYPE_ROOT_PORT << 4 | 2) << 16 |
 540                                 PCI_CAP_ID_EXP;
 541                 }
 542                 break;
 543
 544         case IPROC_PCI_EXP_CAP + PCI_EXP_RTCTL:
 545                 /* Don't advertise CRS SV support */
 546                 *val &= ~(PCI_EXP_RTCAP_CRSVIS << 16);
 547                 break;
 548
 549         default:
 550                 break;
 551         }
 552 }
 553
 554 static int iproc_pcie_config_read(struct pci_bus *bus, unsigned int devfn,
 555                                   int where, int size, u32 *val)
 556 {
 557         struct iproc_pcie *pcie = iproc_data(bus);
 558         unsigned int slot = PCI_SLOT(devfn);
 559         unsigned int fn = PCI_FUNC(devfn);
 560         unsigned int busno = bus->number;
 561         void __iomem *cfg_data_p;
 562         unsigned int data;
 563         int ret;
 564
 565         /* root complex access */
 566         if (busno == 0) {
 567                 ret = pci_generic_config_read32(bus, devfn, where, size, val);
 568                 if (ret == PCIBIOS_SUCCESSFUL)
 569                         iproc_pcie_fix_cap(pcie, where, val);
 570
 571                 return ret;
 572         }
 573
 574         cfg_data_p = iproc_pcie_map_ep_cfg_reg(pcie, busno, slot, fn, where);
 575
 576         if (!cfg_data_p)
 577                 return PCIBIOS_DEVICE_NOT_FOUND;
 578
 579         data = iproc_pcie_cfg_retry(cfg_data_p);
 580
 581         *val = data;
 582         if (size <= 2)
 583                 *val = (data >> (8 * (where & 3))) & ((1 << (size * 8)) - 1);
 584
 585         /*
 586          * For PAXC and PAXCv2, the total number of PFs that one can enumerate
 587          * depends on the firmware configuration. Unfortunately, due to an ASIC
 588          * bug, unconfigured PFs cannot be properly hidden from the root
 589          * complex. As a result, write access to these PFs will cause bus lock
 590          * up on the embedded processor
 591          *
 592          * Since all unconfigured PFs are left with an incorrect, staled device
 593          * ID of 0x168e (PCI_DEVICE_ID_NX2_57810), we try to catch those access
 594          * early here and reject them all
 595          */
 596 #define DEVICE_ID_MASK     0xffff0000
 597 #define DEVICE_ID_SHIFT    16
 598         if (pcie->rej_unconfig_pf &&
 599             (where & CFG_ADDR_REG_NUM_MASK) == PCI_VENDOR_ID)
 600                 if ((*val & DEVICE_ID_MASK) ==
 601                     (PCI_DEVICE_ID_NX2_57810 << DEVICE_ID_SHIFT))
 602                         return PCIBIOS_FUNC_NOT_SUPPORTED;
 603
 604         return PCIBIOS_SUCCESSFUL;
 605 }
 606
 607 /**
 608  * Note access to the configuration registers are protected at the higher layer
 609  * by 'pci_lock' in drivers/pci/access.c
 610  */
 611 static void __iomem *iproc_pcie_map_cfg_bus(struct iproc_pcie *pcie,
 612                                             int busno, unsigned int devfn,
 613                                             int where)
 614 {
 615         unsigned slot = PCI_SLOT(devfn);
 616         unsigned fn = PCI_FUNC(devfn);
 617         u16 offset;
 618
 619         /* root complex access */
 620         if (busno == 0) {
 621                 if (slot > 0 || fn > 0)
 622                         return NULL;
 623
 624                 iproc_pcie_write_reg(pcie, IPROC_PCIE_CFG_IND_ADDR,
 625                                      where & CFG_IND_ADDR_MASK);
 626                 offset = iproc_pcie_reg_offset(pcie, IPROC_PCIE_CFG_IND_DATA);
 627                 if (iproc_pcie_reg_is_invalid(offset))
 628                         return NULL;
 629                 else
 630                         return (pcie->base + offset);
 631         }
 632
 633         return iproc_pcie_map_ep_cfg_reg(pcie, busno, slot, fn, where);
 634 }
 635
 636 static void __iomem *iproc_pcie_bus_map_cfg_bus(struct pci_bus *bus,
 637                                                 unsigned int devfn,
 638                                                 int where)
 639 {
 640         return iproc_pcie_map_cfg_bus(iproc_data(bus), bus->number, devfn,
 641                                       where);
 642 }
 643
 644 static int iproc_pci_raw_config_read32(struct iproc_pcie *pcie,
 645                                        unsigned int devfn, int where,
 646                                        int size, u32 *val)
 647 {
 648         void __iomem *addr;
 649
 650         addr = iproc_pcie_map_cfg_bus(pcie, 0, devfn, where & ~0x3);
 651         if (!addr) {
 652                 *val = ~0;
 653                 return PCIBIOS_DEVICE_NOT_FOUND;
 654         }
 655
 656         *val = readl(addr);
 657
 658         if (size <= 2)
 659                 *val = (*val >> (8 * (where & 3))) & ((1 << (size * 8)) - 1);
 660
 661         return PCIBIOS_SUCCESSFUL;
 662 }
 663
 664 static int iproc_pci_raw_config_write32(struct iproc_pcie *pcie,
 665                                         unsigned int devfn, int where,
 666                                         int size, u32 val)
 667 {
 668         void __iomem *addr;
 669         u32 mask, tmp;
 670
 671         addr = iproc_pcie_map_cfg_bus(pcie, 0, devfn, where & ~0x3);
 672         if (!addr)
 673                 return PCIBIOS_DEVICE_NOT_FOUND;
 674
 675         if (size == 4) {
 676                 writel(val, addr);
 677                 return PCIBIOS_SUCCESSFUL;
 678         }
 679
 680         mask = ~(((1 << (size * 8)) - 1) << ((where & 0x3) * 8));
 681         tmp = readl(addr) & mask;
 682         tmp |= val << ((where & 0x3) * 8);
 683         writel(tmp, addr);
 684
 685         return PCIBIOS_SUCCESSFUL;
 686 }
 687
 688 static int iproc_pcie_config_read32(struct pci_bus *bus, unsigned int devfn,
 689                                     int where, int size, u32 *val)
 690 {
 691         int ret;
 692         struct iproc_pcie *pcie = iproc_data(bus);
 693
 694         iproc_pcie_apb_err_disable(bus, true);
 695         if (pcie->iproc_cfg_read)
 696                 ret = iproc_pcie_config_read(bus, devfn, where, size, val);
 697         else
 698                 ret = pci_generic_config_read32(bus, devfn, where, size, val);
 699         iproc_pcie_apb_err_disable(bus, false);
 700
 701         return ret;
 702 }
 703
 704 static int iproc_pcie_config_write32(struct pci_bus *bus, unsigned int devfn,
 705                                      int where, int size, u32 val)
 706 {
 707         int ret;
 708
 709         iproc_pcie_apb_err_disable(bus, true);
 710         ret = pci_generic_config_write32(bus, devfn, where, size, val);
 711         iproc_pcie_apb_err_disable(bus, false);
 712
 713         return ret;
 714 }
 715
 716 static struct pci_ops iproc_pcie_ops = {
 717         .map_bus = iproc_pcie_bus_map_cfg_bus,
 718         .read = iproc_pcie_config_read32,
 719         .write = iproc_pcie_config_write32,
 720 };
 721
 722 static void iproc_pcie_perst_ctrl(struct iproc_pcie *pcie, bool assert)
 723 {
 724         u32 val;
 725
 726         /*
 727          * PAXC and the internal emulated endpoint device downstream should not
 728          * be reset.  If firmware has been loaded on the endpoint device at an
 729          * earlier boot stage, reset here causes issues.
 730          */
 731         if (pcie->ep_is_internal)
 732                 return;
 733
 734         if (assert) {
 735                 val = iproc_pcie_read_reg(pcie, IPROC_PCIE_CLK_CTRL);
 736                 val &= ~EP_PERST_SOURCE_SELECT & ~EP_MODE_SURVIVE_PERST &
 737                         ~RC_PCIE_RST_OUTPUT;
 738                 iproc_pcie_write_reg(pcie, IPROC_PCIE_CLK_CTRL, val);
 739                 udelay(250);
 740         } else {
 741                 val = iproc_pcie_read_reg(pcie, IPROC_PCIE_CLK_CTRL);
 742                 val |= RC_PCIE_RST_OUTPUT;
 743                 iproc_pcie_write_reg(pcie, IPROC_PCIE_CLK_CTRL, val);
 744                 msleep(100);
 745         }
 746 }
 747
 748 int iproc_pcie_shutdown(struct iproc_pcie *pcie)
 749 {
 750         iproc_pcie_perst_ctrl(pcie, true);
 751         msleep(500);
 752
 753         return 0;
 754 }
 755 EXPORT_SYMBOL_GPL(iproc_pcie_shutdown);
 756
 757 static int iproc_pcie_check_link(struct iproc_pcie *pcie)
 758 {
 759         struct device *dev = pcie->dev;
 760         u32 hdr_type, link_ctrl, link_status, class, val;
 761         bool link_is_active = false;
 762
 763         /*
 764          * PAXC connects to emulated endpoint devices directly and does not
 765          * have a Serdes.  Therefore skip the link detection logic here.
 766          */
 767         if (pcie->ep_is_internal)
 768                 return 0;
 769
 770         val = iproc_pcie_read_reg(pcie, IPROC_PCIE_LINK_STATUS);
 771         if (!(val & PCIE_PHYLINKUP) || !(val & PCIE_DL_ACTIVE)) {
 772                 dev_err(dev, "PHY or data link is INACTIVE!\n");
 773                 return -ENODEV;
 774         }
 775
 776         /* make sure we are not in EP mode */
 777         iproc_pci_raw_config_read32(pcie, 0, PCI_HEADER_TYPE, 1, &hdr_type);
 778         if ((hdr_type & 0x7f) != PCI_HEADER_TYPE_BRIDGE) {
 779                 dev_err(dev, "in EP mode, hdr=%#02x\n", hdr_type);
 780                 return -EFAULT;
 781         }
 782
 783         /* force class to PCI_CLASS_BRIDGE_PCI (0x0604) */
 784 #define PCI_BRIDGE_CTRL_REG_OFFSET      0x43c
 785 #define PCI_CLASS_BRIDGE_MASK           0xffff00
 786 #define PCI_CLASS_BRIDGE_SHIFT          8
 787         iproc_pci_raw_config_read32(pcie, 0, PCI_BRIDGE_CTRL_REG_OFFSET,
 788                                     4, &class);
 789         class &= ~PCI_CLASS_BRIDGE_MASK;
 790         class |= (PCI_CLASS_BRIDGE_PCI << PCI_CLASS_BRIDGE_SHIFT);
 791         iproc_pci_raw_config_write32(pcie, 0, PCI_BRIDGE_CTRL_REG_OFFSET,
 792                                      4, class);
 793
 794         /* check link status to see if link is active */
 795         iproc_pci_raw_config_read32(pcie, 0, IPROC_PCI_EXP_CAP + PCI_EXP_LNKSTA,
 796                                     2, &link_status);
 797         if (link_status & PCI_EXP_LNKSTA_NLW)
 798                 link_is_active = true;
 799
 800         if (!link_is_active) {
 801                 /* try GEN 1 link speed */
 802 #define PCI_TARGET_LINK_SPEED_MASK      0xf
 803 #define PCI_TARGET_LINK_SPEED_GEN2      0x2
 804 #define PCI_TARGET_LINK_SPEED_GEN1      0x1
 805                 iproc_pci_raw_config_read32(pcie, 0,
 806                                             IPROC_PCI_EXP_CAP + PCI_EXP_LNKCTL2,
 807                                             4, &link_ctrl);
 808                 if ((link_ctrl & PCI_TARGET_LINK_SPEED_MASK) ==
 809                     PCI_TARGET_LINK_SPEED_GEN2) {
 810                         link_ctrl &= ~PCI_TARGET_LINK_SPEED_MASK;
 811                         link_ctrl |= PCI_TARGET_LINK_SPEED_GEN1;
 812                         iproc_pci_raw_config_write32(pcie, 0,
 813                                         IPROC_PCI_EXP_CAP + PCI_EXP_LNKCTL2,
 814                                         4, link_ctrl);
 815                         msleep(100);
 816
 817                         iproc_pci_raw_config_read32(pcie, 0,
 818                                         IPROC_PCI_EXP_CAP + PCI_EXP_LNKSTA,
 819                                         2, &link_status);
 820                         if (link_status & PCI_EXP_LNKSTA_NLW)
 821                                 link_is_active = true;
 822                 }
 823         }
 824
 825         dev_info(dev, "link: %s\n", link_is_active ? "UP" : "DOWN");
 826
 827         return link_is_active ? 0 : -ENODEV;
 828 }
 829
 830 static void iproc_pcie_enable(struct iproc_pcie *pcie)
 831 {
 832         iproc_pcie_write_reg(pcie, IPROC_PCIE_INTX_EN, SYS_RC_INTX_MASK);
 833 }
 834
 835 static inline bool iproc_pcie_ob_is_valid(struct iproc_pcie *pcie,
 836                                           int window_idx)
 837 {
 838         u32 val;
 839
 840         val = iproc_pcie_read_reg(pcie, MAP_REG(IPROC_PCIE_OARR0, window_idx));
 841
 842         return !!(val & OARR_VALID);
 843 }
 844
 845 static inline int iproc_pcie_ob_write(struct iproc_pcie *pcie, int window_idx,
 846                                       int size_idx, u64 axi_addr, u64 pci_addr)
 847 {
 848         struct device *dev = pcie->dev;
 849         u16 oarr_offset, omap_offset;
 850
 851         /*
 852          * Derive the OARR/OMAP offset from the first pair (OARR0/OMAP0) based
 853          * on window index.
 854          */
 855         oarr_offset = iproc_pcie_reg_offset(pcie, MAP_REG(IPROC_PCIE_OARR0,
 856                                                           window_idx));
 857         omap_offset = iproc_pcie_reg_offset(pcie, MAP_REG(IPROC_PCIE_OMAP0,
 858                                                           window_idx));
 859         if (iproc_pcie_reg_is_invalid(oarr_offset) ||
 860             iproc_pcie_reg_is_invalid(omap_offset))
 861                 return -EINVAL;
 862
 863         /*
 864          * Program the OARR registers.  The upper 32-bit OARR register is
 865          * always right after the lower 32-bit OARR register.
 866          */
 867         writel(lower_32_bits(axi_addr) | (size_idx << OARR_SIZE_CFG_SHIFT) |
 868                OARR_VALID, pcie->base + oarr_offset);
 869         writel(upper_32_bits(axi_addr), pcie->base + oarr_offset + 4);
 870
 871         /* now program the OMAP registers */
 872         writel(lower_32_bits(pci_addr), pcie->base + omap_offset);
 873         writel(upper_32_bits(pci_addr), pcie->base + omap_offset + 4);
 874
 875         dev_dbg(dev, "ob window [%d]: offset 0x%x axi %pap pci %pap\n",
 876                 window_idx, oarr_offset, &axi_addr, &pci_addr);
 877         dev_dbg(dev, "oarr lo 0x%x oarr hi 0x%x\n",
 878                 readl(pcie->base + oarr_offset),
 879                 readl(pcie->base + oarr_offset + 4));
 880         dev_dbg(dev, "omap lo 0x%x omap hi 0x%x\n",
 881                 readl(pcie->base + omap_offset),
 882                 readl(pcie->base + omap_offset + 4));
 883
 884         return 0;
 885 }
 886
 887 /**
 888  * Some iProc SoCs require the SW to configure the outbound address mapping
 889  *
 890  * Outbound address translation:
 891  *
 892  * iproc_pcie_address = axi_address - axi_offset
 893  * OARR = iproc_pcie_address
 894  * OMAP = pci_addr
 895  *
 896  * axi_addr -> iproc_pcie_address -> OARR -> OMAP -> pci_address
 897  */
 898 static int iproc_pcie_setup_ob(struct iproc_pcie *pcie, u64 axi_addr,
 899                                u64 pci_addr, resource_size_t size)
 900 {
 901         struct iproc_pcie_ob *ob = &pcie->ob;
 902         struct device *dev = pcie->dev;
 903         int ret = -EINVAL, window_idx, size_idx;
 904
 905         if (axi_addr < ob->axi_offset) {
 906                 dev_err(dev, "axi address %pap less than offset %pap\n",
 907                         &axi_addr, &ob->axi_offset);
 908                 return -EINVAL;
 909         }
 910
 911         /*
 912          * Translate the AXI address to the internal address used by the iProc
 913          * PCIe core before programming the OARR
 914          */
 915         axi_addr -= ob->axi_offset;
 916
 917         /* iterate through all OARR/OMAP mapping windows */
 918         for (window_idx = ob->nr_windows - 1; window_idx >= 0; window_idx--) {
 919                 const struct iproc_pcie_ob_map *ob_map =
 920                         &pcie->ob_map[window_idx];
 921
 922                 /*
 923                  * If current outbound window is already in use, move on to the
 924                  * next one.
 925                  */
 926                 if (iproc_pcie_ob_is_valid(pcie, window_idx))
 927                         continue;
 928
 929                 /*
 930                  * Iterate through all supported window sizes within the
 931                  * OARR/OMAP pair to find a match.  Go through the window sizes
 932                  * in a descending order.
 933                  */
 934                 for (size_idx = ob_map->nr_sizes - 1; size_idx >= 0;
 935                      size_idx--) {
 936                         resource_size_t window_size =
 937                                 ob_map->window_sizes[size_idx] * SZ_1M;
 938
 939                         if (size < window_size)
 940                                 continue;
 941
 942                         if (!IS_ALIGNED(axi_addr, window_size) ||
 943                             !IS_ALIGNED(pci_addr, window_size)) {
 944                                 dev_err(dev,
 945                                         "axi %pap or pci %pap not aligned\n",
 946                                         &axi_addr, &pci_addr);
 947                                 return -EINVAL;
 948                         }
 949
 950                         /*
 951                          * Match found!  Program both OARR and OMAP and mark
 952                          * them as a valid entry.
 953                          */
 954                         ret = iproc_pcie_ob_write(pcie, window_idx, size_idx,
 955                                                   axi_addr, pci_addr);
 956                         if (ret)
 957                                 goto err_ob;
 958
 959                         size -= window_size;
 960                         if (size == 0)
 961                                 return 0;
 962
 963                         /*
 964                          * If we are here, we are done with the current window,
 965                          * but not yet finished all mappings.  Need to move on
 966                          * to the next window.
 967                          */
 968                         axi_addr += window_size;
 969                         pci_addr += window_size;
 970                         break;
 971                 }
 972         }
 973
 974 err_ob:
 975         dev_err(dev, "unable to configure outbound mapping\n");
 976         dev_err(dev,
 977                 "axi %pap, axi offset %pap, pci %pap, res size %pap\n",
 978                 &axi_addr, &ob->axi_offset, &pci_addr, &size);
 979
 980         return ret;
 981 }
 982
 983 static int iproc_pcie_map_ranges(struct iproc_pcie *pcie,
 984                                  struct list_head *resources)
 985 {
 986         struct device *dev = pcie->dev;
 987         struct resource_entry *window;
 988         int ret;
 989
 990         resource_list_for_each_entry(window, resources) {
 991                 struct resource *res = window->res;
 992                 u64 res_type = resource_type(res);
 993
 994                 switch (res_type) {
 995                 case IORESOURCE_IO:
 996                 case IORESOURCE_BUS:
 997                         break;
 998                 case IORESOURCE_MEM:
 999                         ret = iproc_pcie_setup_ob(pcie, res->start,
1000                                                   res->start - window->offset,
1001                                                   resource_size(res));
1002                         if (ret)
1003                                 return ret;
1004                         break;
1005                 default:
1006                         dev_err(dev, "invalid resource %pR\n", res);
1007                         return -EINVAL;
1008                 }
1009         }
1010
1011         return 0;
1012 }
1013
1014 static inline bool iproc_pcie_ib_is_in_use(struct iproc_pcie *pcie,
1015                                            int region_idx)
1016 {
1017         const struct iproc_pcie_ib_map *ib_map = &pcie->ib_map[region_idx];
1018         u32 val;
1019
1020         val = iproc_pcie_read_reg(pcie, MAP_REG(IPROC_PCIE_IARR0, region_idx));
1021
1022         return !!(val & (BIT(ib_map->nr_sizes) - 1));
1023 }
1024
1025 static inline bool iproc_pcie_ib_check_type(const struct iproc_pcie_ib_map *ib_map,
1026                                             enum iproc_pcie_ib_map_type type)
1027 {
1028         return !!(ib_map->type == type);
1029 }
1030
1031 static int iproc_pcie_ib_write(struct iproc_pcie *pcie, int region_idx,
1032                                int size_idx, int nr_windows, u64 axi_addr,
1033                                u64 pci_addr, resource_size_t size)
1034 {
1035         struct device *dev = pcie->dev;
1036         const struct iproc_pcie_ib_map *ib_map = &pcie->ib_map[region_idx];
1037         u16 iarr_offset, imap_offset;
1038         u32 val;
1039         int window_idx;
1040
1041         iarr_offset = iproc_pcie_reg_offset(pcie,
1042                                 MAP_REG(IPROC_PCIE_IARR0, region_idx));
1043         imap_offset = iproc_pcie_reg_offset(pcie,
1044                                 MAP_REG(IPROC_PCIE_IMAP0, region_idx));
1045         if (iproc_pcie_reg_is_invalid(iarr_offset) ||
1046             iproc_pcie_reg_is_invalid(imap_offset))
1047                 return -EINVAL;
1048
1049         dev_dbg(dev, "ib region [%d]: offset 0x%x axi %pap pci %pap\n",
1050                 region_idx, iarr_offset, &axi_addr, &pci_addr);
1051
1052         /*
1053          * Program the IARR registers.  The upper 32-bit IARR register is
1054          * always right after the lower 32-bit IARR register.
1055          */
1056         writel(lower_32_bits(pci_addr) | BIT(size_idx),
1057                pcie->base + iarr_offset);
1058         writel(upper_32_bits(pci_addr), pcie->base + iarr_offset + 4);
1059
1060         dev_dbg(dev, "iarr lo 0x%x iarr hi 0x%x\n",
1061                 readl(pcie->base + iarr_offset),
1062                 readl(pcie->base + iarr_offset + 4));
1063
1064         /*
1065          * Now program the IMAP registers.  Each IARR region may have one or
1066          * more IMAP windows.
1067          */
1068         size >>= ilog2(nr_windows);
1069         for (window_idx = 0; window_idx < nr_windows; window_idx++) {
1070                 val = readl(pcie->base + imap_offset);
1071                 val |= lower_32_bits(axi_addr) | IMAP_VALID;
1072                 writel(val, pcie->base + imap_offset);
1073                 writel(upper_32_bits(axi_addr),
1074                        pcie->base + imap_offset + ib_map->imap_addr_offset);
1075
1076                 dev_dbg(dev, "imap window [%d] lo 0x%x hi 0x%x\n",
1077                         window_idx, readl(pcie->base + imap_offset),
1078                         readl(pcie->base + imap_offset +
1079                               ib_map->imap_addr_offset));
1080
1081                 imap_offset += ib_map->imap_window_offset;
1082                 axi_addr += size;
1083         }
1084
1085         return 0;
1086 }
1087
1088 static int iproc_pcie_setup_ib(struct iproc_pcie *pcie,
1089                                struct of_pci_range *range,
1090                                enum iproc_pcie_ib_map_type type)
1091 {
1092         struct device *dev = pcie->dev;
1093         struct iproc_pcie_ib *ib = &pcie->ib;
1094         int ret;
1095         unsigned int region_idx, size_idx;
1096         u64 axi_addr = range->cpu_addr, pci_addr = range->pci_addr;
1097         resource_size_t size = range->size;
1098
1099         /* iterate through all IARR mapping regions */
1100         for (region_idx = 0; region_idx < ib->nr_regions; region_idx++) {
1101                 const struct iproc_pcie_ib_map *ib_map =
1102                         &pcie->ib_map[region_idx];
1103
1104                 /*
1105                  * If current inbound region is already in use or not a
1106                  * compatible type, move on to the next.
1107                  */
1108                 if (iproc_pcie_ib_is_in_use(pcie, region_idx) ||
1109                     !iproc_pcie_ib_check_type(ib_map, type))
1110                         continue;
1111
1112                 /* iterate through all supported region sizes to find a match */
1113                 for (size_idx = 0; size_idx < ib_map->nr_sizes; size_idx++) {
1114                         resource_size_t region_size =
1115                         ib_map->region_sizes[size_idx] * ib_map->size_unit;
1116
1117                         if (size != region_size)
1118                                 continue;
1119
1120                         if (!IS_ALIGNED(axi_addr, region_size) ||
1121                             !IS_ALIGNED(pci_addr, region_size)) {
1122                                 dev_err(dev,
1123                                         "axi %pap or pci %pap not aligned\n",
1124                                         &axi_addr, &pci_addr);
1125                                 return -EINVAL;
1126                         }
1127
1128                         /* Match found!  Program IARR and all IMAP windows. */
1129                         ret = iproc_pcie_ib_write(pcie, region_idx, size_idx,
1130                                                   ib_map->nr_windows, axi_addr,
1131                                                   pci_addr, size);
1132                         if (ret)
1133                                 goto err_ib;
1134                         else
1135                                 return 0;
1136
1137                 }
1138         }
1139         ret = -EINVAL;
1140
1141 err_ib:
1142         dev_err(dev, "unable to configure inbound mapping\n");
1143         dev_err(dev, "axi %pap, pci %pap, res size %pap\n",
1144                 &axi_addr, &pci_addr, &size);
1145
1146         return ret;
1147 }
1148
1149 static int iproc_pcie_map_dma_ranges(struct iproc_pcie *pcie)
1150 {
1151         struct of_pci_range range;
1152         struct of_pci_range_parser parser;
1153         int ret;
1154
1155         /* Get the dma-ranges from DT */
1156         ret = of_pci_dma_range_parser_init(&parser, pcie->dev->of_node);
1157         if (ret)
1158                 return ret;
1159
1160         for_each_of_pci_range(&parser, &range) {
1161                 /* Each range entry corresponds to an inbound mapping region */
1162                 ret = iproc_pcie_setup_ib(pcie, &range, IPROC_PCIE_IB_MAP_MEM);
1163                 if (ret)
1164                         return ret;
1165         }
1166
1167         return 0;
1168 }
1169
1170 static int iproce_pcie_get_msi(struct iproc_pcie *pcie,
1171                                struct device_node *msi_node,
1172                                u64 *msi_addr)
1173 {
1174         struct device *dev = pcie->dev;
1175         int ret;
1176         struct resource res;
1177
1178         /*
1179          * Check if 'msi-map' points to ARM GICv3 ITS, which is the only
1180          * supported external MSI controller that requires steering.
1181          */
1182         if (!of_device_is_compatible(msi_node, "arm,gic-v3-its")) {
1183                 dev_err(dev, "unable to find compatible MSI controller\n");
1184                 return -ENODEV;
1185         }
1186
1187         /* derive GITS_TRANSLATER address from GICv3 */
1188         ret = of_address_to_resource(msi_node, 0, &res);
1189         if (ret < 0) {
1190                 dev_err(dev, "unable to obtain MSI controller resources\n");
1191                 return ret;
1192         }
1193
1194         *msi_addr = res.start + GITS_TRANSLATER;
1195         return 0;
1196 }
1197
1198 static int iproc_pcie_paxb_v2_msi_steer(struct iproc_pcie *pcie, u64 msi_addr)
1199 {
1200         int ret;
1201         struct of_pci_range range;
1202
1203         memset(&range, 0, sizeof(range));
1204         range.size = SZ_32K;
1205         range.pci_addr = range.cpu_addr = msi_addr & ~(range.size - 1);
1206
1207         ret = iproc_pcie_setup_ib(pcie, &range, IPROC_PCIE_IB_MAP_IO);
1208         return ret;
1209 }
1210
1211 static void iproc_pcie_paxc_v2_msi_steer(struct iproc_pcie *pcie, u64 msi_addr,
1212                                          bool enable)
1213 {
1214         u32 val;
1215
1216         if (!enable) {
1217                 /*
1218                  * Disable PAXC MSI steering. All write transfers will be
1219                  * treated as non-MSI transfers
1220                  */
1221                 val = iproc_pcie_read_reg(pcie, IPROC_PCIE_MSI_EN_CFG);
1222                 val &= ~MSI_ENABLE_CFG;
1223                 iproc_pcie_write_reg(pcie, IPROC_PCIE_MSI_EN_CFG, val);
1224                 return;
1225         }
1226
1227         /*
1228          * Program bits [43:13] of address of GITS_TRANSLATER register into
1229          * bits [30:0] of the MSI base address register.  In fact, in all iProc
1230          * based SoCs, all I/O register bases are well below the 32-bit
1231          * boundary, so we can safely assume bits [43:32] are always zeros.
1232          */
1233         iproc_pcie_write_reg(pcie, IPROC_PCIE_MSI_BASE_ADDR,
1234                              (u32)(msi_addr >> 13));
1235
1236         /* use a default 8K window size */
1237         iproc_pcie_write_reg(pcie, IPROC_PCIE_MSI_WINDOW_SIZE, 0);
1238
1239         /* steering MSI to GICv3 ITS */
1240         val = iproc_pcie_read_reg(pcie, IPROC_PCIE_MSI_GIC_MODE);
1241         val |= GIC_V3_CFG;
1242         iproc_pcie_write_reg(pcie, IPROC_PCIE_MSI_GIC_MODE, val);
1243
1244         /*
1245          * Program bits [43:2] of address of GITS_TRANSLATER register into the
1246          * iProc MSI address registers.
1247          */
1248         msi_addr >>= 2;
1249         iproc_pcie_write_reg(pcie, IPROC_PCIE_MSI_ADDR_HI,
1250                              upper_32_bits(msi_addr));
1251         iproc_pcie_write_reg(pcie, IPROC_PCIE_MSI_ADDR_LO,
1252                              lower_32_bits(msi_addr));
1253
1254         /* enable MSI */
1255         val = iproc_pcie_read_reg(pcie, IPROC_PCIE_MSI_EN_CFG);
1256         val |= MSI_ENABLE_CFG;
1257         iproc_pcie_write_reg(pcie, IPROC_PCIE_MSI_EN_CFG, val);
1258 }
1259
1260 static int iproc_pcie_msi_steer(struct iproc_pcie *pcie,
1261                                 struct device_node *msi_node)
1262 {
1263         struct device *dev = pcie->dev;
1264         int ret;
1265         u64 msi_addr;
1266
1267         ret = iproce_pcie_get_msi(pcie, msi_node, &msi_addr);
1268         if (ret < 0) {
1269                 dev_err(dev, "msi steering failed\n");
1270                 return ret;
1271         }
1272
1273         switch (pcie->type) {
1274         case IPROC_PCIE_PAXB_V2:
1275                 ret = iproc_pcie_paxb_v2_msi_steer(pcie, msi_addr);
1276                 if (ret)
1277                         return ret;
1278                 break;
1279         case IPROC_PCIE_PAXC_V2:
1280                 iproc_pcie_paxc_v2_msi_steer(pcie, msi_addr, true);
1281                 break;
1282         default:
1283                 return -EINVAL;
1284         }
1285
1286         return 0;
1287 }
1288
1289 static int iproc_pcie_msi_enable(struct iproc_pcie *pcie)
1290 {
1291         struct device_node *msi_node;
1292         int ret;
1293
1294         /*
1295          * Either the "msi-parent" or the "msi-map" phandle needs to exist
1296          * for us to obtain the MSI node.
1297          */
1298
1299         msi_node = of_parse_phandle(pcie->dev->of_node, "msi-parent", 0);
1300         if (!msi_node) {
1301                 const __be32 *msi_map = NULL;
1302                 int len;
1303                 u32 phandle;
1304
1305                 msi_map = of_get_property(pcie->dev->of_node, "msi-map", &len);
1306                 if (!msi_map)
1307                         return -ENODEV;
1308
1309                 phandle = be32_to_cpup(msi_map + 1);
1310                 msi_node = of_find_node_by_phandle(phandle);
1311                 if (!msi_node)
1312                         return -ENODEV;
1313         }
1314
1315         /*
1316          * Certain revisions of the iProc PCIe controller require additional
1317          * configurations to steer the MSI writes towards an external MSI
1318          * controller.
1319          */
1320         if (pcie->need_msi_steer) {
1321                 ret = iproc_pcie_msi_steer(pcie, msi_node);
1322                 if (ret)
1323                         return ret;
1324         }
1325
1326         /*
1327          * If another MSI controller is being used, the call below should fail
1328          * but that is okay
1329          */
1330         return iproc_msi_init(pcie, msi_node);
1331 }
1332
1333 static void iproc_pcie_msi_disable(struct iproc_pcie *pcie)
1334 {
1335         iproc_msi_exit(pcie);
1336 }
1337
1338 static int iproc_pcie_rev_init(struct iproc_pcie *pcie)
1339 {
1340         struct device *dev = pcie->dev;
1341         unsigned int reg_idx;
1342         const u16 *regs;
1343
1344         switch (pcie->type) {
1345         case IPROC_PCIE_PAXB_BCMA:
1346                 regs = iproc_pcie_reg_paxb_bcma;
1347                 break;
1348         case IPROC_PCIE_PAXB:
1349                 regs = iproc_pcie_reg_paxb;
1350                 pcie->has_apb_err_disable = true;
1351                 if (pcie->need_ob_cfg) {
1352                         pcie->ob_map = paxb_ob_map;
1353                         pcie->ob.nr_windows = ARRAY_SIZE(paxb_ob_map);
1354                 }
1355                 break;
1356         case IPROC_PCIE_PAXB_V2:
1357                 regs = iproc_pcie_reg_paxb_v2;
1358                 pcie->iproc_cfg_read = true;
1359                 pcie->has_apb_err_disable = true;
1360                 if (pcie->need_ob_cfg) {
1361                         pcie->ob_map = paxb_v2_ob_map;
1362                         pcie->ob.nr_windows = ARRAY_SIZE(paxb_v2_ob_map);
1363                 }
1364                 pcie->ib.nr_regions = ARRAY_SIZE(paxb_v2_ib_map);
1365                 pcie->ib_map = paxb_v2_ib_map;
1366                 pcie->need_msi_steer = true;
1367                 dev_warn(dev, "reads of config registers that contain %#x return incorrect data\n",
1368                          CFG_RETRY_STATUS);
1369                 break;
1370         case IPROC_PCIE_PAXC:
1371                 regs = iproc_pcie_reg_paxc;
1372                 pcie->ep_is_internal = true;
1373                 pcie->iproc_cfg_read = true;
1374                 pcie->rej_unconfig_pf = true;
1375                 break;
1376         case IPROC_PCIE_PAXC_V2:
1377                 regs = iproc_pcie_reg_paxc_v2;
1378                 pcie->ep_is_internal = true;
1379                 pcie->iproc_cfg_read = true;
1380                 pcie->rej_unconfig_pf = true;
1381                 pcie->need_msi_steer = true;
1382                 break;
1383         default:
1384                 dev_err(dev, "incompatible iProc PCIe interface\n");
1385                 return -EINVAL;
1386         }
1387
1388         pcie->reg_offsets = devm_kcalloc(dev, IPROC_PCIE_MAX_NUM_REG,
1389                                          sizeof(*pcie->reg_offsets),
1390                                          GFP_KERNEL);
1391         if (!pcie->reg_offsets)
1392                 return -ENOMEM;
1393
1394         /* go through the register table and populate all valid registers */
1395         pcie->reg_offsets[0] = (pcie->type == IPROC_PCIE_PAXC_V2) ?
1396                 IPROC_PCIE_REG_INVALID : regs[0];
1397         for (reg_idx = 1; reg_idx < IPROC_PCIE_MAX_NUM_REG; reg_idx++)
1398                 pcie->reg_offsets[reg_idx] = regs[reg_idx] ?
1399                         regs[reg_idx] : IPROC_PCIE_REG_INVALID;
1400
1401         return 0;
1402 }
1403
1404 int iproc_pcie_setup(struct iproc_pcie *pcie, struct list_head *res)
1405 {
1406         struct device *dev;
1407         int ret;
1408         struct pci_bus *child;
1409         struct pci_host_bridge *host = pci_host_bridge_from_priv(pcie);
1410
1411         dev = pcie->dev;
1412
1413         ret = iproc_pcie_rev_init(pcie);
1414         if (ret) {
1415                 dev_err(dev, "unable to initialize controller parameters\n");
1416                 return ret;
1417         }
1418
1419         ret = devm_request_pci_bus_resources(dev, res);
1420         if (ret)
1421                 return ret;
1422
1423         ret = phy_init(pcie->phy);
1424         if (ret) {
1425                 dev_err(dev, "unable to initialize PCIe PHY\n");
1426                 return ret;
1427         }
1428
1429         ret = phy_power_on(pcie->phy);
1430         if (ret) {
1431                 dev_err(dev, "unable to power on PCIe PHY\n");
1432                 goto err_exit_phy;
1433         }
1434
1435         iproc_pcie_perst_ctrl(pcie, true);
1436         iproc_pcie_perst_ctrl(pcie, false);
1437
1438         if (pcie->need_ob_cfg) {
1439                 ret = iproc_pcie_map_ranges(pcie, res);
1440                 if (ret) {
1441                         dev_err(dev, "map failed\n");
1442                         goto err_power_off_phy;
1443                 }
1444         }
1445
1446         if (pcie->need_ib_cfg) {
1447                 ret = iproc_pcie_map_dma_ranges(pcie);
1448                 if (ret && ret != -ENOENT)
1449                         goto err_power_off_phy;
1450         }
1451
1452         ret = iproc_pcie_check_link(pcie);
1453         if (ret) {
1454                 dev_err(dev, "no PCIe EP device detected\n");
1455                 goto err_power_off_phy;
1456         }
1457
1458         iproc_pcie_enable(pcie);
1459
1460         if (IS_ENABLED(CONFIG_PCI_MSI))
1461                 if (iproc_pcie_msi_enable(pcie))
1462                         dev_info(dev, "not using iProc MSI\n");
1463
1464         list_splice_init(res, &host->windows);
1465         host->busnr = 0;
1466         host->dev.parent = dev;
1467         host->ops = &iproc_pcie_ops;
1468         host->sysdata = pcie;
1469         host->map_irq = pcie->map_irq;
1470         host->swizzle_irq = pci_common_swizzle;
1471
1472         ret = pci_scan_root_bus_bridge(host);
1473         if (ret < 0) {
1474                 dev_err(dev, "failed to scan host: %d\n", ret);
1475                 goto err_power_off_phy;
1476         }
1477
1478         pci_assign_unassigned_bus_resources(host->bus);
1479
1480         pcie->root_bus = host->bus;
1481
1482         list_for_each_entry(child, &host->bus->children, node)
1483                 pcie_bus_configure_settings(child);
1484
1485         pci_bus_add_devices(host->bus);
1486
1487         return 0;
1488
1489 err_power_off_phy:
1490         phy_power_off(pcie->phy);
1491 err_exit_phy:
1492         phy_exit(pcie->phy);
1493         return ret;
1494 }
1495 EXPORT_SYMBOL(iproc_pcie_setup);
1496
1497 int iproc_pcie_remove(struct iproc_pcie *pcie)
1498 {
1499         pci_stop_root_bus(pcie->root_bus);
1500         pci_remove_root_bus(pcie->root_bus);
1501
1502         iproc_pcie_msi_disable(pcie);
1503
1504         phy_power_off(pcie->phy);
1505         phy_exit(pcie->phy);
1506
1507         return 0;
1508 }
1509 EXPORT_SYMBOL(iproc_pcie_remove);
1510
1511 /*
1512  * The MSI parsing logic in certain revisions of Broadcom PAXC based root
1513  * complex does not work and needs to be disabled
1514  */
1515 static void quirk_paxc_disable_msi_parsing(struct pci_dev *pdev)
1516 {
1517         struct iproc_pcie *pcie = iproc_data(pdev->bus);
1518
1519         if (pdev->hdr_type == PCI_HEADER_TYPE_BRIDGE)
1520                 iproc_pcie_paxc_v2_msi_steer(pcie, 0, false);
1521 }
1522 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_BROADCOM, 0x16f0,
1523                         quirk_paxc_disable_msi_parsing);
1524 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_BROADCOM, 0xd802,
1525                         quirk_paxc_disable_msi_parsing);
1526 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_BROADCOM, 0xd804,
1527                         quirk_paxc_disable_msi_parsing);
1528
1529 static void quirk_paxc_bridge(struct pci_dev *pdev)
1530 {
1531         /*
1532          * The PCI config space is shared with the PAXC root port and the first
1533          * Ethernet device.  So, we need to workaround this by telling the PCI
1534          * code that the bridge is not an Ethernet device.
1535          */
1536         if (pdev->hdr_type == PCI_HEADER_TYPE_BRIDGE)
1537                 pdev->class = PCI_CLASS_BRIDGE_PCI << 8;
1538
1539         /*
1540          * MPSS is not being set properly (as it is currently 0).  This is
1541          * because that area of the PCI config space is hard coded to zero, and
1542          * is not modifiable by firmware.  Set this to 2 (e.g., 512 byte MPS)
1543          * so that the MPS can be set to the real max value.
1544          */
1545         pdev->pcie_mpss = 2;
1546 }
1547 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_BROADCOM, 0x16cd, quirk_paxc_bridge);
1548 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_BROADCOM, 0x16f0, quirk_paxc_bridge);
1549 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_BROADCOM, 0xd750, quirk_paxc_bridge);
1550 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_BROADCOM, 0xd802, quirk_paxc_bridge);
1551 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_BROADCOM, 0xd804, quirk_paxc_bridge);
1552
1553 MODULE_AUTHOR("Ray Jui <rjui@broadcom.com>");
1554 MODULE_DESCRIPTION("Broadcom iPROC PCIe common driver");
1555 MODULE_LICENSE("GPL v2");