enable_rpm_wakeref_asserts(&i915->runtime_pm);
 }
 
-static __always_inline irqreturn_t
-__gen11_irq_handler(struct drm_i915_private * const i915,
-                   u32 (*intr_disable)(void __iomem * const regs),
-                   void (*intr_enable)(void __iomem * const regs))
+static irqreturn_t gen11_irq_handler(int irq, void *arg)
 {
+       struct drm_i915_private *i915 = arg;
        void __iomem * const regs = i915->uncore.regs;
        struct intel_gt *gt = &i915->gt;
        u32 master_ctl;
        if (!intel_irqs_enabled(i915))
                return IRQ_NONE;
 
-       master_ctl = intr_disable(regs);
+       master_ctl = gen11_master_intr_disable(regs);
        if (!master_ctl) {
-               intr_enable(regs);
+               gen11_master_intr_enable(regs);
                return IRQ_NONE;
        }
 
 
        gu_misc_iir = gen11_gu_misc_irq_ack(gt, master_ctl);
 
-       intr_enable(regs);
+       gen11_master_intr_enable(regs);
 
        gen11_gu_misc_irq_handler(gt, gu_misc_iir);
 
        return IRQ_HANDLED;
 }
 
-static irqreturn_t gen11_irq_handler(int irq, void *arg)
-{
-       return __gen11_irq_handler(arg,
-                                  gen11_master_intr_disable,
-                                  gen11_master_intr_enable);
-}
-
-static u32 dg1_master_intr_disable_and_ack(void __iomem * const regs)
+static inline u32 dg1_master_intr_disable(void __iomem * const regs)
 {
        u32 val;
 
        /* First disable interrupts */
-       raw_reg_write(regs, DG1_MSTR_UNIT_INTR, 0);
+       raw_reg_write(regs, DG1_MSTR_TILE_INTR, 0);
 
        /* Get the indication levels and ack the master unit */
-       val = raw_reg_read(regs, DG1_MSTR_UNIT_INTR);
+       val = raw_reg_read(regs, DG1_MSTR_TILE_INTR);
        if (unlikely(!val))
                return 0;
 
-       raw_reg_write(regs, DG1_MSTR_UNIT_INTR, val);
-
-       /*
-        * Now with master disabled, get a sample of level indications
-        * for this interrupt and ack them right away - we keep GEN11_MASTER_IRQ
-        * out as this bit doesn't exist anymore for DG1
-        */
-       val = raw_reg_read(regs, GEN11_GFX_MSTR_IRQ) & ~GEN11_MASTER_IRQ;
-       if (unlikely(!val))
-               return 0;
-
-       raw_reg_write(regs, GEN11_GFX_MSTR_IRQ, val);
+       raw_reg_write(regs, DG1_MSTR_TILE_INTR, val);
 
        return val;
 }
 
 static inline void dg1_master_intr_enable(void __iomem * const regs)
 {
-       raw_reg_write(regs, DG1_MSTR_UNIT_INTR, DG1_MSTR_IRQ);
+       raw_reg_write(regs, DG1_MSTR_TILE_INTR, DG1_MSTR_IRQ);
 }
 
 static irqreturn_t dg1_irq_handler(int irq, void *arg)
 {
-       return __gen11_irq_handler(arg,
-                                  dg1_master_intr_disable_and_ack,
-                                  dg1_master_intr_enable);
+       struct drm_i915_private * const i915 = arg;
+       struct intel_gt *gt = &i915->gt;
+       void __iomem * const regs = i915->uncore.regs;
+       u32 master_tile_ctl, master_ctl;
+       u32 gu_misc_iir;
+
+       if (!intel_irqs_enabled(i915))
+               return IRQ_NONE;
+
+       master_tile_ctl = dg1_master_intr_disable(regs);
+       if (!master_tile_ctl) {
+               dg1_master_intr_enable(regs);
+               return IRQ_NONE;
+       }
+
+       /* FIXME: we only support tile 0 for now. */
+       if (master_tile_ctl & DG1_MSTR_TILE(0)) {
+               master_ctl = raw_reg_read(regs, GEN11_GFX_MSTR_IRQ);
+               raw_reg_write(regs, GEN11_GFX_MSTR_IRQ, master_ctl);
+       } else {
+               DRM_ERROR("Tile not supported: 0x%08x\n", master_tile_ctl);
+               dg1_master_intr_enable(regs);
+               return IRQ_NONE;
+       }
+
+       gen11_gt_irq_handler(gt, master_ctl);
+
+       if (master_ctl & GEN11_DISPLAY_IRQ)
+               gen11_display_irq_handler(i915);
+
+       gu_misc_iir = gen11_gu_misc_irq_ack(gt, master_ctl);
+
+       dg1_master_intr_enable(regs);
+
+       gen11_gu_misc_irq_handler(gt, gu_misc_iir);
+
+       pmu_irq_stats(i915, IRQ_HANDLED);
+
+       return IRQ_HANDLED;
 }
 
 /* Called from drm generic code, passed 'crtc' which
 {
        struct intel_uncore *uncore = &dev_priv->uncore;
 
-       if (HAS_MASTER_UNIT_IRQ(dev_priv))
-               dg1_master_intr_disable_and_ack(dev_priv->uncore.regs);
-       else
-               gen11_master_intr_disable(dev_priv->uncore.regs);
+       gen11_master_intr_disable(dev_priv->uncore.regs);
+
+       gen11_gt_irq_reset(&dev_priv->gt);
+       gen11_display_irq_reset(dev_priv);
+
+       GEN3_IRQ_RESET(uncore, GEN11_GU_MISC_);
+       GEN3_IRQ_RESET(uncore, GEN8_PCU_);
+}
+
+static void dg1_irq_reset(struct drm_i915_private *dev_priv)
+{
+       struct intel_uncore *uncore = &dev_priv->uncore;
+
+       dg1_master_intr_disable(dev_priv->uncore.regs);
 
        gen11_gt_irq_reset(&dev_priv->gt);
        gen11_display_irq_reset(dev_priv);
 
        GEN3_IRQ_INIT(uncore, GEN11_GU_MISC_, ~gu_misc_masked, gu_misc_masked);
 
-       if (HAS_MASTER_UNIT_IRQ(dev_priv)) {
-               dg1_master_intr_enable(uncore->regs);
-               intel_uncore_posting_read(&dev_priv->uncore, DG1_MSTR_UNIT_INTR);
-       } else {
-               gen11_master_intr_enable(uncore->regs);
-               intel_uncore_posting_read(&dev_priv->uncore, GEN11_GFX_MSTR_IRQ);
+       gen11_master_intr_enable(uncore->regs);
+       intel_uncore_posting_read(&dev_priv->uncore, GEN11_GFX_MSTR_IRQ);
+}
+
+static void dg1_irq_postinstall(struct drm_i915_private *dev_priv)
+{
+       struct intel_uncore *uncore = &dev_priv->uncore;
+       u32 gu_misc_masked = GEN11_GU_MISC_GSE;
+
+       gen11_gt_irq_postinstall(&dev_priv->gt);
+
+       GEN3_IRQ_INIT(uncore, GEN11_GU_MISC_, ~gu_misc_masked, gu_misc_masked);
+
+       if (HAS_DISPLAY(dev_priv)) {
+               icp_irq_postinstall(dev_priv);
+               gen8_de_irq_postinstall(dev_priv);
+               intel_uncore_write(&dev_priv->uncore, GEN11_DISPLAY_INT_CTL,
+                                  GEN11_DISPLAY_IRQ_ENABLE);
        }
+
+       dg1_master_intr_enable(dev_priv->uncore.regs);
+       intel_uncore_posting_read(&dev_priv->uncore, DG1_MSTR_TILE_INTR);
 }
 
 static void cherryview_irq_postinstall(struct drm_i915_private *dev_priv)
                else
                        return i8xx_irq_handler;
        } else {
-               if (HAS_MASTER_UNIT_IRQ(dev_priv))
+               if (GRAPHICS_VER_FULL(dev_priv) >= IP_VER(12, 10))
                        return dg1_irq_handler;
-               if (GRAPHICS_VER(dev_priv) >= 11)
+               else if (GRAPHICS_VER(dev_priv) >= 11)
                        return gen11_irq_handler;
                else if (GRAPHICS_VER(dev_priv) >= 8)
                        return gen8_irq_handler;
                else
                        i8xx_irq_reset(dev_priv);
        } else {
-               if (GRAPHICS_VER(dev_priv) >= 11)
+               if (GRAPHICS_VER_FULL(dev_priv) >= IP_VER(12, 10))
+                       dg1_irq_reset(dev_priv);
+               else if (GRAPHICS_VER(dev_priv) >= 11)
                        gen11_irq_reset(dev_priv);
                else if (GRAPHICS_VER(dev_priv) >= 8)
                        gen8_irq_reset(dev_priv);
                else
                        i8xx_irq_postinstall(dev_priv);
        } else {
-               if (GRAPHICS_VER(dev_priv) >= 11)
+               if (GRAPHICS_VER_FULL(dev_priv) >= IP_VER(12, 10))
+                       dg1_irq_postinstall(dev_priv);
+               else if (GRAPHICS_VER(dev_priv) >= 11)
                        gen11_irq_postinstall(dev_priv);
                else if (GRAPHICS_VER(dev_priv) >= 8)
                        gen8_irq_postinstall(dev_priv);