LXR linux/drivers/pci/controller/pcie-xilinx.c

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * PCIe host controller driver for Xilinx AXI PCIe Bridge
   4 *
   5 * Copyright (c) 2012 - 2014 Xilinx, Inc.
   6 *
   7 * Based on the Tegra PCIe driver
   8 *
   9 * Bits taken from Synopsys DesignWare Host controller driver and
  10 * ARM PCI Host generic driver.
  11 */
  12
  13#include <linux/interrupt.h>
  14#include <linux/irq.h>
  15#include <linux/irqdomain.h>
  16#include <linux/kernel.h>
  17#include <linux/init.h>
  18#include <linux/msi.h>
  19#include <linux/of_address.h>
  20#include <linux/of_pci.h>
  21#include <linux/of_platform.h>
  22#include <linux/of_irq.h>
  23#include <linux/pci.h>
  24#include <linux/platform_device.h>
  25
  26#include "../pci.h"
  27
  28/* Register definitions */
  29#define XILINX_PCIE_REG_BIR             0x00000130
  30#define XILINX_PCIE_REG_IDR             0x00000138
  31#define XILINX_PCIE_REG_IMR             0x0000013c
  32#define XILINX_PCIE_REG_PSCR            0x00000144
  33#define XILINX_PCIE_REG_RPSC            0x00000148
  34#define XILINX_PCIE_REG_MSIBASE1        0x0000014c
  35#define XILINX_PCIE_REG_MSIBASE2        0x00000150
  36#define XILINX_PCIE_REG_RPEFR           0x00000154
  37#define XILINX_PCIE_REG_RPIFR1          0x00000158
  38#define XILINX_PCIE_REG_RPIFR2          0x0000015c
  39
  40/* Interrupt registers definitions */
  41#define XILINX_PCIE_INTR_LINK_DOWN      BIT(0)
  42#define XILINX_PCIE_INTR_ECRC_ERR       BIT(1)
  43#define XILINX_PCIE_INTR_STR_ERR        BIT(2)
  44#define XILINX_PCIE_INTR_HOT_RESET      BIT(3)
  45#define XILINX_PCIE_INTR_CFG_TIMEOUT    BIT(8)
  46#define XILINX_PCIE_INTR_CORRECTABLE    BIT(9)
  47#define XILINX_PCIE_INTR_NONFATAL       BIT(10)
  48#define XILINX_PCIE_INTR_FATAL          BIT(11)
  49#define XILINX_PCIE_INTR_INTX           BIT(16)
  50#define XILINX_PCIE_INTR_MSI            BIT(17)
  51#define XILINX_PCIE_INTR_SLV_UNSUPP     BIT(20)
  52#define XILINX_PCIE_INTR_SLV_UNEXP      BIT(21)
  53#define XILINX_PCIE_INTR_SLV_COMPL      BIT(22)
  54#define XILINX_PCIE_INTR_SLV_ERRP       BIT(23)
  55#define XILINX_PCIE_INTR_SLV_CMPABT     BIT(24)
  56#define XILINX_PCIE_INTR_SLV_ILLBUR     BIT(25)
  57#define XILINX_PCIE_INTR_MST_DECERR     BIT(26)
  58#define XILINX_PCIE_INTR_MST_SLVERR     BIT(27)
  59#define XILINX_PCIE_INTR_MST_ERRP       BIT(28)
  60#define XILINX_PCIE_IMR_ALL_MASK        0x1FF30FED
  61#define XILINX_PCIE_IMR_ENABLE_MASK     0x1FF30F0D
  62#define XILINX_PCIE_IDR_ALL_MASK        0xFFFFFFFF
  63
  64/* Root Port Error FIFO Read Register definitions */
  65#define XILINX_PCIE_RPEFR_ERR_VALID     BIT(18)
  66#define XILINX_PCIE_RPEFR_REQ_ID        GENMASK(15, 0)
  67#define XILINX_PCIE_RPEFR_ALL_MASK      0xFFFFFFFF
  68
  69/* Root Port Interrupt FIFO Read Register 1 definitions */
  70#define XILINX_PCIE_RPIFR1_INTR_VALID   BIT(31)
  71#define XILINX_PCIE_RPIFR1_MSI_INTR     BIT(30)
  72#define XILINX_PCIE_RPIFR1_INTR_MASK    GENMASK(28, 27)
  73#define XILINX_PCIE_RPIFR1_ALL_MASK     0xFFFFFFFF
  74#define XILINX_PCIE_RPIFR1_INTR_SHIFT   27
  75
  76/* Bridge Info Register definitions */
  77#define XILINX_PCIE_BIR_ECAM_SZ_MASK    GENMASK(18, 16)
  78#define XILINX_PCIE_BIR_ECAM_SZ_SHIFT   16
  79
  80/* Root Port Interrupt FIFO Read Register 2 definitions */
  81#define XILINX_PCIE_RPIFR2_MSG_DATA     GENMASK(15, 0)
  82
  83/* Root Port Status/control Register definitions */
  84#define XILINX_PCIE_REG_RPSC_BEN        BIT(0)
  85
  86/* Phy Status/Control Register definitions */
  87#define XILINX_PCIE_REG_PSCR_LNKUP      BIT(11)
  88
  89/* ECAM definitions */
  90#define ECAM_BUS_NUM_SHIFT              20
  91#define ECAM_DEV_NUM_SHIFT              12
  92
  93/* Number of MSI IRQs */
  94#define XILINX_NUM_MSI_IRQS             128
  95
  96/**
  97 * struct xilinx_pcie_port - PCIe port information
  98 * @reg_base: IO Mapped Register Base
  99 * @irq: Interrupt number
 100 * @msi_pages: MSI pages
 101 * @root_busno: Root Bus number
 102 * @dev: Device pointer
 103 * @msi_domain: MSI IRQ domain pointer
 104 * @leg_domain: Legacy IRQ domain pointer
 105 * @resources: Bus Resources
 106 */
 107struct xilinx_pcie_port {
 108        void __iomem *reg_base;
 109        u32 irq;
 110        unsigned long msi_pages;
 111        u8 root_busno;
 112        struct device *dev;
 113        struct irq_domain *msi_domain;
 114        struct irq_domain *leg_domain;
 115        struct list_head resources;
 116};
 117
 118static DECLARE_BITMAP(msi_irq_in_use, XILINX_NUM_MSI_IRQS);
 119
 120static inline u32 pcie_read(struct xilinx_pcie_port *port, u32 reg)
 121{
 122        return readl(port->reg_base + reg);
 123}
 124
 125static inline void pcie_write(struct xilinx_pcie_port *port, u32 val, u32 reg)
 126{
 127        writel(val, port->reg_base + reg);
 128}
 129
 130static inline bool xilinx_pcie_link_up(struct xilinx_pcie_port *port)
 131{
 132        return (pcie_read(port, XILINX_PCIE_REG_PSCR) &
 133                XILINX_PCIE_REG_PSCR_LNKUP) ? 1 : 0;
 134}
 135
 136/**
 137 * xilinx_pcie_clear_err_interrupts - Clear Error Interrupts
 138 * @port: PCIe port information
 139 */
 140static void xilinx_pcie_clear_err_interrupts(struct xilinx_pcie_port *port)
 141{
 142        struct device *dev = port->dev;
 143        unsigned long val = pcie_read(port, XILINX_PCIE_REG_RPEFR);
 144
 145        if (val & XILINX_PCIE_RPEFR_ERR_VALID) {
 146                dev_dbg(dev, "Requester ID %lu\n",
 147                        val & XILINX_PCIE_RPEFR_REQ_ID);
 148                pcie_write(port, XILINX_PCIE_RPEFR_ALL_MASK,
 149                           XILINX_PCIE_REG_RPEFR);
 150        }
 151}
 152
 153/**
 154 * xilinx_pcie_valid_device - Check if a valid device is present on bus
 155 * @bus: PCI Bus structure
 156 * @devfn: device/function
 157 *
 158 * Return: 'true' on success and 'false' if invalid device is found
 159 */
 160static bool xilinx_pcie_valid_device(struct pci_bus *bus, unsigned int devfn)
 161{
 162        struct xilinx_pcie_port *port = bus->sysdata;
 163
 164        /* Check if link is up when trying to access downstream ports */
 165        if (bus->number != port->root_busno)
 166                if (!xilinx_pcie_link_up(port))
 167                        return false;
 168
 169        /* Only one device down on each root port */
 170        if (bus->number == port->root_busno && devfn > 0)
 171                return false;
 172
 173        return true;
 174}
 175
 176/**
 177 * xilinx_pcie_map_bus - Get configuration base
 178 * @bus: PCI Bus structure
 179 * @devfn: Device/function
 180 * @where: Offset from base
 181 *
 182 * Return: Base address of the configuration space needed to be
 183 *         accessed.
 184 */
 185static void __iomem *xilinx_pcie_map_bus(struct pci_bus *bus,
 186                                         unsigned int devfn, int where)
 187{
 188        struct xilinx_pcie_port *port = bus->sysdata;
 189        int relbus;
 190
 191        if (!xilinx_pcie_valid_device(bus, devfn))
 192                return NULL;
 193
 194        relbus = (bus->number << ECAM_BUS_NUM_SHIFT) |
 195                 (devfn << ECAM_DEV_NUM_SHIFT);
 196
 197        return port->reg_base + relbus + where;
 198}
 199
 200/* PCIe operations */
 201static struct pci_ops xilinx_pcie_ops = {
 202        .map_bus = xilinx_pcie_map_bus,
 203        .read   = pci_generic_config_read,
 204        .write  = pci_generic_config_write,
 205};
 206
 207/* MSI functions */
 208
 209/**
 210 * xilinx_pcie_destroy_msi - Free MSI number
 211 * @irq: IRQ to be freed
 212 */
 213static void xilinx_pcie_destroy_msi(unsigned int irq)
 214{
 215        struct msi_desc *msi;
 216        struct xilinx_pcie_port *port;
 217        struct irq_data *d = irq_get_irq_data(irq);
 218        irq_hw_number_t hwirq = irqd_to_hwirq(d);
 219
 220        if (!test_bit(hwirq, msi_irq_in_use)) {
 221                msi = irq_get_msi_desc(irq);
 222                port = msi_desc_to_pci_sysdata(msi);
 223                dev_err(port->dev, "Trying to free unused MSI#%d\n", irq);
 224        } else {
 225                clear_bit(hwirq, msi_irq_in_use);
 226        }
 227}
 228
 229/**
 230 * xilinx_pcie_assign_msi - Allocate MSI number
 231 *
 232 * Return: A valid IRQ on success and error value on failure.
 233 */
 234static int xilinx_pcie_assign_msi(void)
 235{
 236        int pos;
 237
 238        pos = find_first_zero_bit(msi_irq_in_use, XILINX_NUM_MSI_IRQS);
 239        if (pos < XILINX_NUM_MSI_IRQS)
 240                set_bit(pos, msi_irq_in_use);
 241        else
 242                return -ENOSPC;
 243
 244        return pos;
 245}
 246
 247/**
 248 * xilinx_msi_teardown_irq - Destroy the MSI
 249 * @chip: MSI Chip descriptor
 250 * @irq: MSI IRQ to destroy
 251 */
 252static void xilinx_msi_teardown_irq(struct msi_controller *chip,
 253                                    unsigned int irq)
 254{
 255        xilinx_pcie_destroy_msi(irq);
 256        irq_dispose_mapping(irq);
 257}
 258
 259/**
 260 * xilinx_pcie_msi_setup_irq - Setup MSI request
 261 * @chip: MSI chip pointer
 262 * @pdev: PCIe device pointer
 263 * @desc: MSI descriptor pointer
 264 *
 265 * Return: '0' on success and error value on failure
 266 */
 267static int xilinx_pcie_msi_setup_irq(struct msi_controller *chip,
 268                                     struct pci_dev *pdev,
 269                                     struct msi_desc *desc)
 270{
 271        struct xilinx_pcie_port *port = pdev->bus->sysdata;
 272        unsigned int irq;
 273        int hwirq;
 274        struct msi_msg msg;
 275        phys_addr_t msg_addr;
 276
 277        hwirq = xilinx_pcie_assign_msi();
 278        if (hwirq < 0)
 279                return hwirq;
 280
 281        irq = irq_create_mapping(port->msi_domain, hwirq);
 282        if (!irq)
 283                return -EINVAL;
 284
 285        irq_set_msi_desc(irq, desc);
 286
 287        msg_addr = virt_to_phys((void *)port->msi_pages);
 288
 289        msg.address_hi = 0;
 290        msg.address_lo = msg_addr;
 291        msg.data = irq;
 292
 293        pci_write_msi_msg(irq, &msg);
 294
 295        return 0;
 296}
 297
 298/* MSI Chip Descriptor */
 299static struct msi_controller xilinx_pcie_msi_chip = {
 300        .setup_irq = xilinx_pcie_msi_setup_irq,
 301        .teardown_irq = xilinx_msi_teardown_irq,
 302};
 303
 304/* HW Interrupt Chip Descriptor */
 305static struct irq_chip xilinx_msi_irq_chip = {
 306        .name = "Xilinx PCIe MSI",
 307        .irq_enable = pci_msi_unmask_irq,
 308        .irq_disable = pci_msi_mask_irq,
 309        .irq_mask = pci_msi_mask_irq,
 310        .irq_unmask = pci_msi_unmask_irq,
 311};
 312
 313/**
 314 * xilinx_pcie_msi_map - Set the handler for the MSI and mark IRQ as valid
 315 * @domain: IRQ domain
 316 * @irq: Virtual IRQ number
 317 * @hwirq: HW interrupt number
 318 *
 319 * Return: Always returns 0.
 320 */
 321static int xilinx_pcie_msi_map(struct irq_domain *domain, unsigned int irq,
 322                               irq_hw_number_t hwirq)
 323{
 324        irq_set_chip_and_handler(irq, &xilinx_msi_irq_chip, handle_simple_irq);
 325        irq_set_chip_data(irq, domain->host_data);
 326
 327        return 0;
 328}
 329
 330/* IRQ Domain operations */
 331static const struct irq_domain_ops msi_domain_ops = {
 332        .map = xilinx_pcie_msi_map,
 333};
 334
 335/**
 336 * xilinx_pcie_enable_msi - Enable MSI support
 337 * @port: PCIe port information
 338 */
 339static void xilinx_pcie_enable_msi(struct xilinx_pcie_port *port)
 340{
 341        phys_addr_t msg_addr;
 342
 343        port->msi_pages = __get_free_pages(GFP_KERNEL, 0);
 344        msg_addr = virt_to_phys((void *)port->msi_pages);
 345        pcie_write(port, 0x0, XILINX_PCIE_REG_MSIBASE1);
 346        pcie_write(port, msg_addr, XILINX_PCIE_REG_MSIBASE2);
 347}
 348
 349/* INTx Functions */
 350
 351/**
 352 * xilinx_pcie_intx_map - Set the handler for the INTx and mark IRQ as valid
 353 * @domain: IRQ domain
 354 * @irq: Virtual IRQ number
 355 * @hwirq: HW interrupt number
 356 *
 357 * Return: Always returns 0.
 358 */
 359static int xilinx_pcie_intx_map(struct irq_domain *domain, unsigned int irq,
 360                                irq_hw_number_t hwirq)
 361{
 362        irq_set_chip_and_handler(irq, &dummy_irq_chip, handle_simple_irq);
 363        irq_set_chip_data(irq, domain->host_data);
 364
 365        return 0;
 366}
 367
 368/* INTx IRQ Domain operations */
 369static const struct irq_domain_ops intx_domain_ops = {
 370        .map = xilinx_pcie_intx_map,
 371        .xlate = pci_irqd_intx_xlate,
 372};
 373
 374/* PCIe HW Functions */
 375
 376/**
 377 * xilinx_pcie_intr_handler - Interrupt Service Handler
 378 * @irq: IRQ number
 379 * @data: PCIe port information
 380 *
 381 * Return: IRQ_HANDLED on success and IRQ_NONE on failure
 382 */
 383static irqreturn_t xilinx_pcie_intr_handler(int irq, void *data)
 384{
 385        struct xilinx_pcie_port *port = (struct xilinx_pcie_port *)data;
 386        struct device *dev = port->dev;
 387        u32 val, mask, status;
 388
 389        /* Read interrupt decode and mask registers */
 390        val = pcie_read(port, XILINX_PCIE_REG_IDR);
 391        mask = pcie_read(port, XILINX_PCIE_REG_IMR);
 392
 393        status = val & mask;
 394        if (!status)
 395                return IRQ_NONE;
 396
 397        if (status & XILINX_PCIE_INTR_LINK_DOWN)
 398                dev_warn(dev, "Link Down\n");
 399
 400        if (status & XILINX_PCIE_INTR_ECRC_ERR)
 401                dev_warn(dev, "ECRC failed\n");
 402
 403        if (status & XILINX_PCIE_INTR_STR_ERR)
 404                dev_warn(dev, "Streaming error\n");
 405
 406        if (status & XILINX_PCIE_INTR_HOT_RESET)
 407                dev_info(dev, "Hot reset\n");
 408
 409        if (status & XILINX_PCIE_INTR_CFG_TIMEOUT)
 410                dev_warn(dev, "ECAM access timeout\n");
 411
 412        if (status & XILINX_PCIE_INTR_CORRECTABLE) {
 413                dev_warn(dev, "Correctable error message\n");
 414                xilinx_pcie_clear_err_interrupts(port);
 415        }
 416
 417        if (status & XILINX_PCIE_INTR_NONFATAL) {
 418                dev_warn(dev, "Non fatal error message\n");
 419                xilinx_pcie_clear_err_interrupts(port);
 420        }
 421
 422        if (status & XILINX_PCIE_INTR_FATAL) {
 423                dev_warn(dev, "Fatal error message\n");
 424                xilinx_pcie_clear_err_interrupts(port);
 425        }
 426
 427        if (status & (XILINX_PCIE_INTR_INTX | XILINX_PCIE_INTR_MSI)) {
 428                val = pcie_read(port, XILINX_PCIE_REG_RPIFR1);
 429
 430                /* Check whether interrupt valid */
 431                if (!(val & XILINX_PCIE_RPIFR1_INTR_VALID)) {
 432                        dev_warn(dev, "RP Intr FIFO1 read error\n");
 433                        goto error;
 434                }
 435
 436                /* Decode the IRQ number */
 437                if (val & XILINX_PCIE_RPIFR1_MSI_INTR) {
 438                        val = pcie_read(port, XILINX_PCIE_REG_RPIFR2) &
 439                                XILINX_PCIE_RPIFR2_MSG_DATA;
 440                } else {
 441                        val = (val & XILINX_PCIE_RPIFR1_INTR_MASK) >>
 442                                XILINX_PCIE_RPIFR1_INTR_SHIFT;
 443                        val = irq_find_mapping(port->leg_domain, val);
 444                }
 445
 446                /* Clear interrupt FIFO register 1 */
 447                pcie_write(port, XILINX_PCIE_RPIFR1_ALL_MASK,
 448                           XILINX_PCIE_REG_RPIFR1);
 449
 450                /* Handle the interrupt */
 451                if (IS_ENABLED(CONFIG_PCI_MSI) ||
 452                    !(val & XILINX_PCIE_RPIFR1_MSI_INTR))
 453                        generic_handle_irq(val);
 454        }
 455
 456        if (status & XILINX_PCIE_INTR_SLV_UNSUPP)
 457                dev_warn(dev, "Slave unsupported request\n");
 458
 459        if (status & XILINX_PCIE_INTR_SLV_UNEXP)
 460                dev_warn(dev, "Slave unexpected completion\n");
 461
 462        if (status & XILINX_PCIE_INTR_SLV_COMPL)
 463                dev_warn(dev, "Slave completion timeout\n");
 464
 465        if (status & XILINX_PCIE_INTR_SLV_ERRP)
 466                dev_warn(dev, "Slave Error Poison\n");
 467
 468        if (status & XILINX_PCIE_INTR_SLV_CMPABT)
 469                dev_warn(dev, "Slave Completer Abort\n");
 470
 471        if (status & XILINX_PCIE_INTR_SLV_ILLBUR)
 472                dev_warn(dev, "Slave Illegal Burst\n");
 473
 474        if (status & XILINX_PCIE_INTR_MST_DECERR)
 475                dev_warn(dev, "Master decode error\n");
 476
 477        if (status & XILINX_PCIE_INTR_MST_SLVERR)
 478                dev_warn(dev, "Master slave error\n");
 479
 480        if (status & XILINX_PCIE_INTR_MST_ERRP)
 481                dev_warn(dev, "Master error poison\n");
 482
 483error:
 484        /* Clear the Interrupt Decode register */
 485        pcie_write(port, status, XILINX_PCIE_REG_IDR);
 486
 487        return IRQ_HANDLED;
 488}
 489
 490/**
 491 * xilinx_pcie_init_irq_domain - Initialize IRQ domain
 492 * @port: PCIe port information
 493 *
 494 * Return: '0' on success and error value on failure
 495 */
 496static int xilinx_pcie_init_irq_domain(struct xilinx_pcie_port *port)
 497{
 498        struct device *dev = port->dev;
 499        struct device_node *node = dev->of_node;
 500        struct device_node *pcie_intc_node;
 501
 502        /* Setup INTx */
 503        pcie_intc_node = of_get_next_child(node, NULL);
 504        if (!pcie_intc_node) {
 505                dev_err(dev, "No PCIe Intc node found\n");
 506                return -ENODEV;
 507        }
 508
 509        port->leg_domain = irq_domain_add_linear(pcie_intc_node, PCI_NUM_INTX,
 510                                                 &intx_domain_ops,
 511                                                 port);
 512        of_node_put(pcie_intc_node);
 513        if (!port->leg_domain) {
 514                dev_err(dev, "Failed to get a INTx IRQ domain\n");
 515                return -ENODEV;
 516        }
 517
 518        /* Setup MSI */
 519        if (IS_ENABLED(CONFIG_PCI_MSI)) {
 520                port->msi_domain = irq_domain_add_linear(node,
 521                                                         XILINX_NUM_MSI_IRQS,
 522                                                         &msi_domain_ops,
 523                                                         &xilinx_pcie_msi_chip);
 524                if (!port->msi_domain) {
 525                        dev_err(dev, "Failed to get a MSI IRQ domain\n");
 526                        return -ENODEV;
 527                }
 528
 529                xilinx_pcie_enable_msi(port);
 530        }
 531
 532        return 0;
 533}
 534
 535/**
 536 * xilinx_pcie_init_port - Initialize hardware
 537 * @port: PCIe port information
 538 */
 539static void xilinx_pcie_init_port(struct xilinx_pcie_port *port)
 540{
 541        struct device *dev = port->dev;
 542
 543        if (xilinx_pcie_link_up(port))
 544                dev_info(dev, "PCIe Link is UP\n");
 545        else
 546                dev_info(dev, "PCIe Link is DOWN\n");
 547
 548        /* Disable all interrupts */
 549        pcie_write(port, ~XILINX_PCIE_IDR_ALL_MASK,
 550                   XILINX_PCIE_REG_IMR);
 551
 552        /* Clear pending interrupts */
 553        pcie_write(port, pcie_read(port, XILINX_PCIE_REG_IDR) &
 554                         XILINX_PCIE_IMR_ALL_MASK,
 555                   XILINX_PCIE_REG_IDR);
 556
 557        /* Enable all interrupts we handle */
 558        pcie_write(port, XILINX_PCIE_IMR_ENABLE_MASK, XILINX_PCIE_REG_IMR);
 559
 560        /* Enable the Bridge enable bit */
 561        pcie_write(port, pcie_read(port, XILINX_PCIE_REG_RPSC) |
 562                         XILINX_PCIE_REG_RPSC_BEN,
 563                   XILINX_PCIE_REG_RPSC);
 564}
 565
 566/**
 567 * xilinx_pcie_parse_dt - Parse Device tree
 568 * @port: PCIe port information
 569 *
 570 * Return: '0' on success and error value on failure
 571 */
 572static int xilinx_pcie_parse_dt(struct xilinx_pcie_port *port)
 573{
 574        struct device *dev = port->dev;
 575        struct device_node *node = dev->of_node;
 576        struct resource regs;
 577        const char *type;
 578        int err;
 579
 580        type = of_get_property(node, "device_type", NULL);
 581        if (!type || strcmp(type, "pci")) {
 582                dev_err(dev, "invalid \"device_type\" %s\n", type);
 583                return -EINVAL;
 584        }
 585
 586        err = of_address_to_resource(node, 0, &regs);
 587        if (err) {
 588                dev_err(dev, "missing \"reg\" property\n");
 589                return err;
 590        }
 591
 592        port->reg_base = devm_pci_remap_cfg_resource(dev, &regs);
 593        if (IS_ERR(port->reg_base))
 594                return PTR_ERR(port->reg_base);
 595
 596        port->irq = irq_of_parse_and_map(node, 0);
 597        err = devm_request_irq(dev, port->irq, xilinx_pcie_intr_handler,
 598                               IRQF_SHARED | IRQF_NO_THREAD,
 599                               "xilinx-pcie", port);
 600        if (err) {
 601                dev_err(dev, "unable to request irq %d\n", port->irq);
 602                return err;
 603        }
 604
 605        return 0;
 606}
 607
 608/**
 609 * xilinx_pcie_probe - Probe function
 610 * @pdev: Platform device pointer
 611 *
 612 * Return: '0' on success and error value on failure
 613 */
 614static int xilinx_pcie_probe(struct platform_device *pdev)
 615{
 616        struct device *dev = &pdev->dev;
 617        struct xilinx_pcie_port *port;
 618        struct pci_bus *bus, *child;
 619        struct pci_host_bridge *bridge;
 620        int err;
 621        resource_size_t iobase = 0;
 622        LIST_HEAD(res);
 623
 624        if (!dev->of_node)
 625                return -ENODEV;
 626
 627        bridge = devm_pci_alloc_host_bridge(dev, sizeof(*port));
 628        if (!bridge)
 629                return -ENODEV;
 630
 631        port = pci_host_bridge_priv(bridge);
 632
 633        port->dev = dev;
 634
 635        err = xilinx_pcie_parse_dt(port);
 636        if (err) {
 637                dev_err(dev, "Parsing DT failed\n");
 638                return err;
 639        }
 640
 641        xilinx_pcie_init_port(port);
 642
 643        err = xilinx_pcie_init_irq_domain(port);
 644        if (err) {
 645                dev_err(dev, "Failed creating IRQ Domain\n");
 646                return err;
 647        }
 648
 649        err = devm_of_pci_get_host_bridge_resources(dev, 0, 0xff, &res,
 650                                                    &iobase);
 651        if (err) {
 652                dev_err(dev, "Getting bridge resources failed\n");
 653                return err;
 654        }
 655
 656        err = devm_request_pci_bus_resources(dev, &res);
 657        if (err)
 658                goto error;
 659
 660
 661        list_splice_init(&res, &bridge->windows);
 662        bridge->dev.parent = dev;
 663        bridge->sysdata = port;
 664        bridge->busnr = 0;
 665        bridge->ops = &xilinx_pcie_ops;
 666        bridge->map_irq = of_irq_parse_and_map_pci;
 667        bridge->swizzle_irq = pci_common_swizzle;
 668
 669#ifdef CONFIG_PCI_MSI
 670        xilinx_pcie_msi_chip.dev = dev;
 671        bridge->msi = &xilinx_pcie_msi_chip;
 672#endif
 673        err = pci_scan_root_bus_bridge(bridge);
 674        if (err < 0)
 675                goto error;
 676
 677        bus = bridge->bus;
 678
 679        pci_assign_unassigned_bus_resources(bus);
 680        list_for_each_entry(child, &bus->children, node)
 681                pcie_bus_configure_settings(child);
 682        pci_bus_add_devices(bus);
 683        return 0;
 684
 685error:
 686        pci_free_resource_list(&res);
 687        return err;
 688}
 689
 690static const struct of_device_id xilinx_pcie_of_match[] = {
 691        { .compatible = "xlnx,axi-pcie-host-1.00.a", },
 692        {}
 693};
 694
 695static struct platform_driver xilinx_pcie_driver = {
 696        .driver = {
 697                .name = "xilinx-pcie",
 698                .of_match_table = xilinx_pcie_of_match,
 699                .suppress_bind_attrs = true,
 700        },
 701        .probe = xilinx_pcie_probe,
 702};
 703builtin_platform_driver(xilinx_pcie_driver);
 704