* @polarity: polarity attributes of hwirq
  * @polarity: polarity attributes of hwirq
  * @shareable: shareable attributes of hwirq
+ * @wake_capable: wake capable attribute of hwirq
  * @ctx: acpi_irq_parse_one_ctx updated by this function
  *
  * Description:
 static inline void acpi_irq_parse_one_match(struct fwnode_handle *fwnode,
                                            u32 hwirq, u8 triggering,
                                            u8 polarity, u8 shareable,
+                                           u8 wake_capable,
                                            struct acpi_irq_parse_one_ctx *ctx)
 {
        if (!fwnode)
                return;
        ctx->rc = 0;
-       *ctx->res_flags = acpi_dev_irq_flags(triggering, polarity, shareable);
+       *ctx->res_flags = acpi_dev_irq_flags(triggering, polarity, shareable, wake_capable);
        ctx->fwspec->fwnode = fwnode;
        ctx->fwspec->param[0] = hwirq;
        ctx->fwspec->param[1] = acpi_dev_get_irq_type(triggering, polarity);
                fwnode = acpi_get_gsi_domain_id(irq->interrupts[ctx->index]);
                acpi_irq_parse_one_match(fwnode, irq->interrupts[ctx->index],
                                         irq->triggering, irq->polarity,
-                                        irq->shareable, ctx);
+                                        irq->shareable, irq->wake_capable, ctx);
                return AE_CTRL_TERMINATE;
        case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
                eirq = &ares->data.extended_irq;
                                                      eirq->interrupts[ctx->index]);
                acpi_irq_parse_one_match(fwnode, eirq->interrupts[ctx->index],
                                         eirq->triggering, eirq->polarity,
-                                        eirq->shareable, ctx);
+                                        eirq->shareable, eirq->wake_capable, ctx);
                return AE_CTRL_TERMINATE;
        }
 
 
  * @triggering: Triggering type as provided by ACPI.
  * @polarity: Interrupt polarity as provided by ACPI.
  * @shareable: Whether or not the interrupt is shareable.
+ * @wake_capable: Wake capability as provided by ACPI.
  */
-unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable)
+unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable, u8 wake_capable)
 {
        unsigned long flags;
 
        if (shareable == ACPI_SHARED)
                flags |= IORESOURCE_IRQ_SHAREABLE;
 
+       if (wake_capable == ACPI_WAKE_CAPABLE)
+               flags |= IORESOURCE_IRQ_WAKECAPABLE;
+
        return flags | IORESOURCE_IRQ;
 }
 EXPORT_SYMBOL_GPL(acpi_dev_irq_flags);
 
 static void acpi_dev_get_irqresource(struct resource *res, u32 gsi,
                                     u8 triggering, u8 polarity, u8 shareable,
-                                    bool check_override)
+                                    u8 wake_capable, bool check_override)
 {
        int irq, p, t;
 
                }
        }
 
-       res->flags = acpi_dev_irq_flags(triggering, polarity, shareable);
+       res->flags = acpi_dev_irq_flags(triggering, polarity, shareable, wake_capable);
        irq = acpi_register_gsi(NULL, gsi, triggering, polarity);
        if (irq >= 0) {
                res->start = irq;
                }
                acpi_dev_get_irqresource(res, irq->interrupts[index],
                                         irq->triggering, irq->polarity,
-                                        irq->shareable, true);
+                                        irq->shareable, irq->wake_capable,
+                                        true);
                break;
        case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
                ext_irq = &ares->data.extended_irq;
                if (is_gsi(ext_irq))
                        acpi_dev_get_irqresource(res, ext_irq->interrupts[index],
                                         ext_irq->triggering, ext_irq->polarity,
-                                        ext_irq->shareable, false);
+                                        ext_irq->shareable, ext_irq->wake_capable,
+                                        false);
                else
                        irqresource_disabled(res, 0);
                break;
 
                if (i >= 0) {
                        flags = acpi_dev_irq_flags(gpio->triggering,
                                                   gpio->polarity,
-                                                  gpio->shareable);
+                                                  gpio->shareable,
+                                                  gpio->wake_capable);
                } else {
                        flags = IORESOURCE_DISABLED;
                }
                if (p->interrupts[i])
                        __set_bit(p->interrupts[i], map.bits);
 
-       flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable);
+       flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable, p->wake_capable);
        pnp_register_irq_resource(dev, option_flags, &map, flags);
 }
 
                }
        }
 
-       flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable);
+       flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable, p->wake_capable);
        pnp_register_irq_resource(dev, option_flags, &map, flags);
 }
 
 
                                     struct resource_win *win);
 bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,
                                         struct resource_win *win);
-unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable);
+unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable, u8 wake_capable);
 unsigned int acpi_dev_get_irq_type(int triggering, int polarity);
 bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
                                 struct resource *res);
 
 #define IORESOURCE_IRQ_HIGHLEVEL       (1<<2)
 #define IORESOURCE_IRQ_LOWLEVEL                (1<<3)
 #define IORESOURCE_IRQ_SHAREABLE       (1<<4)
-#define IORESOURCE_IRQ_OPTIONAL        (1<<5)
+#define IORESOURCE_IRQ_OPTIONAL                (1<<5)
+#define IORESOURCE_IRQ_WAKECAPABLE     (1<<6)
 
 /* PnP DMA specific bits (IORESOURCE_BITS) */
 #define IORESOURCE_DMA_TYPE_MASK       (3<<0)