0x01000000 0 0x00000000 0x1e160000 0 0x00010000 /* io space */
                >;
 
-               #interrupt-cells = <1>;
-               interrupt-map-mask = <0xF0000 0 0 1>;
-               interrupt-map = <0x10000 0 0 1 &gic GIC_SHARED 4 IRQ_TYPE_LEVEL_HIGH>,
-                               <0x20000 0 0 1 &gic GIC_SHARED 24 IRQ_TYPE_LEVEL_HIGH>,
-                               <0x30000 0 0 1 &gic GIC_SHARED 25 IRQ_TYPE_LEVEL_HIGH>;
+               interrupt-parent = <&gic>;
+               interrupts = <GIC_SHARED 4 IRQ_TYPE_LEVEL_HIGH
+                               GIC_SHARED 24 IRQ_TYPE_LEVEL_HIGH
+                               GIC_SHARED 25 IRQ_TYPE_LEVEL_HIGH>;
 
                status = "disabled";
 
 
  * @pcie_rst: pointer to port reset control
  * @gpio_rst: gpio reset
  * @slot: port slot
+ * @irq: GIC irq
  * @enabled: indicates if port is enabled
  */
 struct mt7621_pcie_port {
        struct reset_control *pcie_rst;
        struct gpio_desc *gpio_rst;
        u32 slot;
+       int irq;
        bool enabled;
 };
 
  * @dev: Pointer to PCIe device
  * @io_map_base: virtual memory base address for io
  * @ports: pointer to PCIe port information
+ * @irq_map: irq mapping info according pcie link status
  * @resets_inverted: depends on chip revision
  * reset lines are inverted.
  */
        } offset;
        unsigned long io_map_base;
        struct list_head ports;
+       int irq_map[PCIE_P2P_MAX];
        bool resets_inverted;
 };
 
        }
 }
 
+static int mt7621_map_irq(const struct pci_dev *pdev, u8 slot, u8 pin)
+{
+       struct mt7621_pcie *pcie = pdev->bus->sysdata;
+       struct device *dev = pcie->dev;
+       int irq = pcie->irq_map[slot];
+
+       dev_info(dev, "bus=%d slot=%d irq=%d\n", pdev->bus->number, slot, irq);
+       return irq;
+}
+
 static int mt7621_pci_parse_request_of_pci_ranges(struct mt7621_pcie *pcie)
 {
        struct device *dev = pcie->dev;
 {
        struct mt7621_pcie_port *port;
        struct device *dev = pcie->dev;
+       struct platform_device *pdev = to_platform_device(dev);
        struct device_node *pnode = dev->of_node;
        struct resource regs;
        char name[10];
        port->slot = slot;
        port->pcie = pcie;
 
+       port->irq = platform_get_irq(pdev, slot);
+       if (port->irq < 0) {
+               dev_err(dev, "Failed to get IRQ for PCIe%d\n", slot);
+               return -ENXIO;
+       }
+
        INIT_LIST_HEAD(&port->list);
        list_add_tail(&port->list, &pcie->ports);
 
 {
        u32 pcie_link_status = 0;
        u32 n;
-       int i;
+       int i = 0;
        u32 p2p_br_devnum[PCIE_P2P_MAX];
+       int irqs[PCIE_P2P_MAX];
        struct mt7621_pcie_port *port;
 
        list_for_each_entry(port, &pcie->ports, list) {
                u32 slot = port->slot;
 
+               irqs[i++] = port->irq;
                if (port->enabled)
                        pcie_link_status |= BIT(slot);
        }
                 (p2p_br_devnum[1] << PCIE_P2P_BR_DEVNUM1_SHIFT) |
                 (p2p_br_devnum[2] << PCIE_P2P_BR_DEVNUM2_SHIFT));
 
+       /* Assign IRQs */
+       n = 0;
+       for (i = 0; i < PCIE_P2P_MAX; i++)
+               if (pcie_link_status & BIT(i))
+                       pcie->irq_map[n++] = irqs[i];
+
+       for (i = n; i < PCIE_P2P_MAX; i++)
+               pcie->irq_map[i] = -1;
+
        return 0;
 }
 
        host->busnr = pcie->busn.start;
        host->dev.parent = pcie->dev;
        host->ops = &mt7621_pci_ops;
-       host->map_irq = of_irq_parse_and_map_pci;
+       host->map_irq = mt7621_map_irq;
        host->swizzle_irq = pci_common_swizzle;
        host->sysdata = pcie;