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 * @dev: Device pointer
 102 * @msi_domain: MSI IRQ domain pointer
 103 * @leg_domain: Legacy IRQ domain pointer
 104 * @resources: Bus Resources
 105 */
 106struct xilinx_pcie_port {
 107        void __iomem *reg_base;
 108        u32 irq;
 109        unsigned long msi_pages;
 110        struct device *dev;
 111        struct irq_domain *msi_domain;
 112        struct irq_domain *leg_domain;
 113        struct list_head resources;
 114};
 115
 116static DECLARE_BITMAP(msi_irq_in_use, XILINX_NUM_MSI_IRQS);
 117
 118static inline u32 pcie_read(struct xilinx_pcie_port *port, u32 reg)
 119{
 120        return readl(port->reg_base + reg);
 121}
 122
 123static inline void pcie_write(struct xilinx_pcie_port *port, u32 val, u32 reg)
 124{
 125        writel(val, port->reg_base + reg);
 126}
 127
 128static inline bool xilinx_pcie_link_up(struct xilinx_pcie_port *port)
 129{
 130        return (pcie_read(port, XILINX_PCIE_REG_PSCR) &
 131                XILINX_PCIE_REG_PSCR_LNKUP) ? 1 : 0;
 132}
 133
 134/**
 135 * xilinx_pcie_clear_err_interrupts - Clear Error Interrupts
 136 * @port: PCIe port information
 137 */
 138static void xilinx_pcie_clear_err_interrupts(struct xilinx_pcie_port *port)
 139{
 140        struct device *dev = port->dev;
 141        unsigned long val = pcie_read(port, XILINX_PCIE_REG_RPEFR);
 142
 143        if (val & XILINX_PCIE_RPEFR_ERR_VALID) {
 144                dev_dbg(dev, "Requester ID %lu\n",
 145                        val & XILINX_PCIE_RPEFR_REQ_ID);
 146                pcie_write(port, XILINX_PCIE_RPEFR_ALL_MASK,
 147                           XILINX_PCIE_REG_RPEFR);
 148        }
 149}
 150
 151/**
 152 * xilinx_pcie_valid_device - Check if a valid device is present on bus
 153 * @bus: PCI Bus structure
 154 * @devfn: device/function
 155 *
 156 * Return: 'true' on success and 'false' if invalid device is found
 157 */
 158static bool xilinx_pcie_valid_device(struct pci_bus *bus, unsigned int devfn)
 159{
 160        struct xilinx_pcie_port *port = bus->sysdata;
 161
 162        /* Check if link is up when trying to access downstream ports */
 163        if (!pci_is_root_bus(bus)) {
 164                if (!xilinx_pcie_link_up(port))
 165                        return false;
 166        } else if (devfn > 0) {
 167                /* Only one device down on each root port */
 168                return false;
 169        }
 170        return true;
 171}
 172
 173/**
 174 * xilinx_pcie_map_bus - Get configuration base
 175 * @bus: PCI Bus structure
 176 * @devfn: Device/function
 177 * @where: Offset from base
 178 *
 179 * Return: Base address of the configuration space needed to be
 180 *         accessed.
 181 */
 182static void __iomem *xilinx_pcie_map_bus(struct pci_bus *bus,
 183                                         unsigned int devfn, int where)
 184{
 185        struct xilinx_pcie_port *port = bus->sysdata;
 186        int relbus;
 187
 188        if (!xilinx_pcie_valid_device(bus, devfn))
 189                return NULL;
 190
 191        relbus = (bus->number << ECAM_BUS_NUM_SHIFT) |
 192                 (devfn << ECAM_DEV_NUM_SHIFT);
 193
 194        return port->reg_base + relbus + where;
 195}
 196
 197/* PCIe operations */
 198static struct pci_ops xilinx_pcie_ops = {
 199        .map_bus = xilinx_pcie_map_bus,
 200        .read   = pci_generic_config_read,
 201        .write  = pci_generic_config_write,
 202};
 203
 204/* MSI functions */
 205
 206/**
 207 * xilinx_pcie_destroy_msi - Free MSI number
 208 * @irq: IRQ to be freed
 209 */
 210static void xilinx_pcie_destroy_msi(unsigned int irq)
 211{
 212        struct msi_desc *msi;
 213        struct xilinx_pcie_port *port;
 214        struct irq_data *d = irq_get_irq_data(irq);
 215        irq_hw_number_t hwirq = irqd_to_hwirq(d);
 216
 217        if (!test_bit(hwirq, msi_irq_in_use)) {
 218                msi = irq_get_msi_desc(irq);
 219                port = msi_desc_to_pci_sysdata(msi);
 220                dev_err(port->dev, "Trying to free unused MSI#%d\n", irq);
 221        } else {
 222                clear_bit(hwirq, msi_irq_in_use);
 223        }
 224}
 225
 226/**
 227 * xilinx_pcie_assign_msi - Allocate MSI number
 228 *
 229 * Return: A valid IRQ on success and error value on failure.
 230 */
 231static int xilinx_pcie_assign_msi(void)
 232{
 233        int pos;
 234
 235        pos = find_first_zero_bit(msi_irq_in_use, XILINX_NUM_MSI_IRQS);
 236        if (pos < XILINX_NUM_MSI_IRQS)
 237                set_bit(pos, msi_irq_in_use);
 238        else
 239                return -ENOSPC;
 240
 241        return pos;
 242}
 243
 244/**
 245 * xilinx_msi_teardown_irq - Destroy the MSI
 246 * @chip: MSI Chip descriptor
 247 * @irq: MSI IRQ to destroy
 248 */
 249static void xilinx_msi_teardown_irq(struct msi_controller *chip,
 250                                    unsigned int irq)
 251{
 252        xilinx_pcie_destroy_msi(irq);
 253        irq_dispose_mapping(irq);
 254}
 255
 256/**
 257 * xilinx_pcie_msi_setup_irq - Setup MSI request
 258 * @chip: MSI chip pointer
 259 * @pdev: PCIe device pointer
 260 * @desc: MSI descriptor pointer
 261 *
 262 * Return: '0' on success and error value on failure
 263 */
 264static int xilinx_pcie_msi_setup_irq(struct msi_controller *chip,
 265                                     struct pci_dev *pdev,
 266                                     struct msi_desc *desc)
 267{
 268        struct xilinx_pcie_port *port = pdev->bus->sysdata;
 269        unsigned int irq;
 270        int hwirq;
 271        struct msi_msg msg;
 272        phys_addr_t msg_addr;
 273
 274        hwirq = xilinx_pcie_assign_msi();
 275        if (hwirq < 0)
 276                return hwirq;
 277
 278        irq = irq_create_mapping(port->msi_domain, hwirq);
 279        if (!irq)
 280                return -EINVAL;
 281
 282        irq_set_msi_desc(irq, desc);
 283
 284        msg_addr = virt_to_phys((void *)port->msi_pages);
 285
 286        msg.address_hi = 0;
 287        msg.address_lo = msg_addr;
 288        msg.data = irq;
 289
 290        pci_write_msi_msg(irq, &msg);
 291
 292        return 0;
 293}
 294
 295/* MSI Chip Descriptor */
 296static struct msi_controller xilinx_pcie_msi_chip = {
 297        .setup_irq = xilinx_pcie_msi_setup_irq,
 298        .teardown_irq = xilinx_msi_teardown_irq,
 299};
 300
 301/* HW Interrupt Chip Descriptor */
 302static struct irq_chip xilinx_msi_irq_chip = {
 303        .name = "Xilinx PCIe MSI",
 304        .irq_enable = pci_msi_unmask_irq,
 305        .irq_disable = pci_msi_mask_irq,
 306        .irq_mask = pci_msi_mask_irq,
 307        .irq_unmask = pci_msi_unmask_irq,
 308};
 309
 310/**
 311 * xilinx_pcie_msi_map - Set the handler for the MSI and mark IRQ as valid
 312 * @domain: IRQ domain
 313 * @irq: Virtual IRQ number
 314 * @hwirq: HW interrupt number
 315 *
 316 * Return: Always returns 0.
 317 */
 318static int xilinx_pcie_msi_map(struct irq_domain *domain, unsigned int irq,
 319                               irq_hw_number_t hwirq)
 320{
 321        irq_set_chip_and_handler(irq, &xilinx_msi_irq_chip, handle_simple_irq);
 322        irq_set_chip_data(irq, domain->host_data);
 323
 324        return 0;
 325}
 326
 327/* IRQ Domain operations */
 328static const struct irq_domain_ops msi_domain_ops = {
 329        .map = xilinx_pcie_msi_map,
 330};
 331
 332/**
 333 * xilinx_pcie_enable_msi - Enable MSI support
 334 * @port: PCIe port information
 335 */
 336static int xilinx_pcie_enable_msi(struct xilinx_pcie_port *port)
 337{
 338        phys_addr_t msg_addr;
 339
 340        port->msi_pages = __get_free_pages(GFP_KERNEL, 0);
 341        if (!port->msi_pages)
 342                return -ENOMEM;
 343
 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        return 0;
 349}
 350
 351/* INTx Functions */
 352
 353/**
 354 * xilinx_pcie_intx_map - Set the handler for the INTx and mark IRQ as valid
 355 * @domain: IRQ domain
 356 * @irq: Virtual IRQ number
 357 * @hwirq: HW interrupt number
 358 *
 359 * Return: Always returns 0.
 360 */
 361static int xilinx_pcie_intx_map(struct irq_domain *domain, unsigned int irq,
 362                                irq_hw_number_t hwirq)
 363{
 364        irq_set_chip_and_handler(irq, &dummy_irq_chip, handle_simple_irq);
 365        irq_set_chip_data(irq, domain->host_data);
 366
 367        return 0;
 368}
 369
 370/* INTx IRQ Domain operations */
 371static const struct irq_domain_ops intx_domain_ops = {
 372        .map = xilinx_pcie_intx_map,
 373        .xlate = pci_irqd_intx_xlate,
 374};
 375
 376/* PCIe HW Functions */
 377
 378/**
 379 * xilinx_pcie_intr_handler - Interrupt Service Handler
 380 * @irq: IRQ number
 381 * @data: PCIe port information
 382 *
 383 * Return: IRQ_HANDLED on success and IRQ_NONE on failure
 384 */
 385static irqreturn_t xilinx_pcie_intr_handler(int irq, void *data)
 386{
 387        struct xilinx_pcie_port *port = (struct xilinx_pcie_port *)data;
 388        struct device *dev = port->dev;
 389        u32 val, mask, status;
 390
 391        /* Read interrupt decode and mask registers */
 392        val = pcie_read(port, XILINX_PCIE_REG_IDR);
 393        mask = pcie_read(port, XILINX_PCIE_REG_IMR);
 394
 395        status = val & mask;
 396        if (!status)
 397                return IRQ_NONE;
 398
 399        if (status & XILINX_PCIE_INTR_LINK_DOWN)
 400                dev_warn(dev, "Link Down\n");
 401
 402        if (status & XILINX_PCIE_INTR_ECRC_ERR)
 403                dev_warn(dev, "ECRC failed\n");
 404
 405        if (status & XILINX_PCIE_INTR_STR_ERR)
 406                dev_warn(dev, "Streaming error\n");
 407
 408        if (status & XILINX_PCIE_INTR_HOT_RESET)
 409                dev_info(dev, "Hot reset\n");
 410
 411        if (status & XILINX_PCIE_INTR_CFG_TIMEOUT)
 412                dev_warn(dev, "ECAM access timeout\n");
 413
 414        if (status & XILINX_PCIE_INTR_CORRECTABLE) {
 415                dev_warn(dev, "Correctable error message\n");
 416                xilinx_pcie_clear_err_interrupts(port);
 417        }
 418
 419        if (status & XILINX_PCIE_INTR_NONFATAL) {
 420                dev_warn(dev, "Non fatal error message\n");
 421                xilinx_pcie_clear_err_interrupts(port);
 422        }
 423
 424        if (status & XILINX_PCIE_INTR_FATAL) {
 425                dev_warn(dev, "Fatal error message\n");
 426                xilinx_pcie_clear_err_interrupts(port);
 427        }
 428
 429        if (status & (XILINX_PCIE_INTR_INTX | XILINX_PCIE_INTR_MSI)) {
 430                val = pcie_read(port, XILINX_PCIE_REG_RPIFR1);
 431
 432                /* Check whether interrupt valid */
 433                if (!(val & XILINX_PCIE_RPIFR1_INTR_VALID)) {
 434                        dev_warn(dev, "RP Intr FIFO1 read error\n");
 435                        goto error;
 436                }
 437
 438                /* Decode the IRQ number */
 439                if (val & XILINX_PCIE_RPIFR1_MSI_INTR) {
 440                        val = pcie_read(port, XILINX_PCIE_REG_RPIFR2) &
 441                                XILINX_PCIE_RPIFR2_MSG_DATA;
 442                } else {
 443                        val = (val & XILINX_PCIE_RPIFR1_INTR_MASK) >>
 444                                XILINX_PCIE_RPIFR1_INTR_SHIFT;
 445                        val = irq_find_mapping(port->leg_domain, val);
 446                }
 447
 448                /* Clear interrupt FIFO register 1 */
 449                pcie_write(port, XILINX_PCIE_RPIFR1_ALL_MASK,
 450                           XILINX_PCIE_REG_RPIFR1);
 451
 452                /* Handle the interrupt */
 453                if (IS_ENABLED(CONFIG_PCI_MSI) ||
 454                    !(val & XILINX_PCIE_RPIFR1_MSI_INTR))
 455                        generic_handle_irq(val);
 456        }
 457
 458        if (status & XILINX_PCIE_INTR_SLV_UNSUPP)
 459                dev_warn(dev, "Slave unsupported request\n");
 460
 461        if (status & XILINX_PCIE_INTR_SLV_UNEXP)
 462                dev_warn(dev, "Slave unexpected completion\n");
 463
 464        if (status & XILINX_PCIE_INTR_SLV_COMPL)
 465                dev_warn(dev, "Slave completion timeout\n");
 466
 467        if (status & XILINX_PCIE_INTR_SLV_ERRP)
 468                dev_warn(dev, "Slave Error Poison\n");
 469
 470        if (status & XILINX_PCIE_INTR_SLV_CMPABT)
 471                dev_warn(dev, "Slave Completer Abort\n");
 472
 473        if (status & XILINX_PCIE_INTR_SLV_ILLBUR)
 474                dev_warn(dev, "Slave Illegal Burst\n");
 475
 476        if (status & XILINX_PCIE_INTR_MST_DECERR)
 477                dev_warn(dev, "Master decode error\n");
 478
 479        if (status & XILINX_PCIE_INTR_MST_SLVERR)
 480                dev_warn(dev, "Master slave error\n");
 481
 482        if (status & XILINX_PCIE_INTR_MST_ERRP)
 483                dev_warn(dev, "Master error poison\n");
 484
 485error:
 486        /* Clear the Interrupt Decode register */
 487        pcie_write(port, status, XILINX_PCIE_REG_IDR);
 488
 489        return IRQ_HANDLED;
 490}
 491
 492/**
 493 * xilinx_pcie_init_irq_domain - Initialize IRQ domain
 494 * @port: PCIe port information
 495 *
 496 * Return: '0' on success and error value on failure
 497 */
 498static int xilinx_pcie_init_irq_domain(struct xilinx_pcie_port *port)
 499{
 500        struct device *dev = port->dev;
 501        struct device_node *node = dev->of_node;
 502        struct device_node *pcie_intc_node;
 503        int ret;
 504
 505        /* Setup INTx */
 506        pcie_intc_node = of_get_next_child(node, NULL);
 507        if (!pcie_intc_node) {
 508                dev_err(dev, "No PCIe Intc node found\n");
 509                return -ENODEV;
 510        }
 511
 512        port->leg_domain = irq_domain_add_linear(pcie_intc_node, PCI_NUM_INTX,
 513                                                 &intx_domain_ops,
 514                                                 port);
 515        of_node_put(pcie_intc_node);
 516        if (!port->leg_domain) {
 517                dev_err(dev, "Failed to get a INTx IRQ domain\n");
 518                return -ENODEV;
 519        }
 520
 521        /* Setup MSI */
 522        if (IS_ENABLED(CONFIG_PCI_MSI)) {
 523                port->msi_domain = irq_domain_add_linear(node,
 524                                                         XILINX_NUM_MSI_IRQS,
 525                                                         &msi_domain_ops,
 526                                                         &xilinx_pcie_msi_chip);
 527                if (!port->msi_domain) {
 528                        dev_err(dev, "Failed to get a MSI IRQ domain\n");
 529                        return -ENODEV;
 530                }
 531
 532                ret = xilinx_pcie_enable_msi(port);
 533                if (ret)
 534                        return ret;
 535        }
 536
 537        return 0;
 538}
 539
 540/**
 541 * xilinx_pcie_init_port - Initialize hardware
 542 * @port: PCIe port information
 543 */
 544static void xilinx_pcie_init_port(struct xilinx_pcie_port *port)
 545{
 546        struct device *dev = port->dev;
 547
 548        if (xilinx_pcie_link_up(port))
 549                dev_info(dev, "PCIe Link is UP\n");
 550        else
 551                dev_info(dev, "PCIe Link is DOWN\n");
 552
 553        /* Disable all interrupts */
 554        pcie_write(port, ~XILINX_PCIE_IDR_ALL_MASK,
 555                   XILINX_PCIE_REG_IMR);
 556
 557        /* Clear pending interrupts */
 558        pcie_write(port, pcie_read(port, XILINX_PCIE_REG_IDR) &
 559                         XILINX_PCIE_IMR_ALL_MASK,
 560                   XILINX_PCIE_REG_IDR);
 561
 562        /* Enable all interrupts we handle */
 563        pcie_write(port, XILINX_PCIE_IMR_ENABLE_MASK, XILINX_PCIE_REG_IMR);
 564
 565        /* Enable the Bridge enable bit */
 566        pcie_write(port, pcie_read(port, XILINX_PCIE_REG_RPSC) |
 567                         XILINX_PCIE_REG_RPSC_BEN,
 568                   XILINX_PCIE_REG_RPSC);
 569}
 570
 571/**
 572 * xilinx_pcie_parse_dt - Parse Device tree
 573 * @port: PCIe port information
 574 *
 575 * Return: '0' on success and error value on failure
 576 */
 577static int xilinx_pcie_parse_dt(struct xilinx_pcie_port *port)
 578{
 579        struct device *dev = port->dev;
 580        struct device_node *node = dev->of_node;
 581        struct resource regs;
 582        int err;
 583
 584        err = of_address_to_resource(node, 0, &regs);
 585        if (err) {
 586                dev_err(dev, "missing \"reg\" property\n");
 587                return err;
 588        }
 589
 590        port->reg_base = devm_pci_remap_cfg_resource(dev, &regs);
 591        if (IS_ERR(port->reg_base))
 592                return PTR_ERR(port->reg_base);
 593
 594        port->irq = irq_of_parse_and_map(node, 0);
 595        err = devm_request_irq(dev, port->irq, xilinx_pcie_intr_handler,
 596                               IRQF_SHARED | IRQF_NO_THREAD,
 597                               "xilinx-pcie", port);
 598        if (err) {
 599                dev_err(dev, "unable to request irq %d\n", port->irq);
 600                return err;
 601        }
 602
 603        return 0;
 604}
 605
 606/**
 607 * xilinx_pcie_probe - Probe function
 608 * @pdev: Platform device pointer
 609 *
 610 * Return: '0' on success and error value on failure
 611 */
 612static int xilinx_pcie_probe(struct platform_device *pdev)
 613{
 614        struct device *dev = &pdev->dev;
 615        struct xilinx_pcie_port *port;
 616        struct pci_host_bridge *bridge;
 617        int err;
 618
 619        if (!dev->of_node)
 620                return -ENODEV;
 621
 622        bridge = devm_pci_alloc_host_bridge(dev, sizeof(*port));
 623        if (!bridge)
 624                return -ENODEV;
 625
 626        port = pci_host_bridge_priv(bridge);
 627
 628        port->dev = dev;
 629
 630        err = xilinx_pcie_parse_dt(port);
 631        if (err) {
 632                dev_err(dev, "Parsing DT failed\n");
 633                return err;
 634        }
 635
 636        xilinx_pcie_init_port(port);
 637
 638        err = xilinx_pcie_init_irq_domain(port);
 639        if (err) {
 640                dev_err(dev, "Failed creating IRQ Domain\n");
 641                return err;
 642        }
 643
 644        bridge->sysdata = port;
 645        bridge->ops = &xilinx_pcie_ops;
 646
 647#ifdef CONFIG_PCI_MSI
 648        xilinx_pcie_msi_chip.dev = dev;
 649        bridge->msi = &xilinx_pcie_msi_chip;
 650#endif
 651        return pci_host_probe(bridge);
 652}
 653
 654static const struct of_device_id xilinx_pcie_of_match[] = {
 655        { .compatible = "xlnx,axi-pcie-host-1.00.a", },
 656        {}
 657};
 658
 659static struct platform_driver xilinx_pcie_driver = {
 660        .driver = {
 661                .name = "xilinx-pcie",
 662                .of_match_table = xilinx_pcie_of_match,
 663                .suppress_bind_attrs = true,
 664        },
 665        .probe = xilinx_pcie_probe,
 666};
 667builtin_platform_driver(xilinx_pcie_driver);
 668