#include <drm/drm_drv.h>
 #include <drm/drm_fb_helper.h>
 #include <drm/drm_gem_cma_helper.h>
-#include <drm/drm_irq.h>
 #include <drm/drm_managed.h>
 #include <drm/drm_probe_helper.h>
 
        .date                   = "20180215",
        .major                  = 1,
        .minor                  = 0,
-
-       .irq_preinstall         = tidss_irq_preinstall,
-       .irq_postinstall        = tidss_irq_postinstall,
-       .irq_handler            = tidss_irq_handler,
-       .irq_uninstall          = tidss_irq_uninstall,
 };
 
 static int tidss_probe(struct platform_device *pdev)
                ret = irq;
                goto err_runtime_suspend;
        }
+       tidss->irq = irq;
 
-       ret = drm_irq_install(ddev, irq);
+       ret = tidss_irq_install(ddev, irq);
        if (ret) {
-               dev_err(dev, "drm_irq_install failed: %d\n", ret);
+               dev_err(dev, "tidss_irq_install failed: %d\n", ret);
                goto err_runtime_suspend;
        }
 
        return 0;
 
 err_irq_uninstall:
-       drm_irq_uninstall(ddev);
+       tidss_irq_uninstall(ddev);
 
 err_runtime_suspend:
 #ifndef CONFIG_PM
 
        drm_atomic_helper_shutdown(ddev);
 
-       drm_irq_uninstall(ddev);
+       tidss_irq_uninstall(ddev);
 
 #ifndef CONFIG_PM
        /* If we don't have PM, we need to call suspend manually */
 
        unsigned int num_planes;
        struct drm_plane *planes[TIDSS_MAX_PLANES];
 
+       unsigned int irq;
+
        spinlock_t wait_lock;   /* protects the irq masks */
        dispc_irq_t irq_mask;   /* enabled irqs in addition to wait_list */
 };
 
  * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
  */
 
+#include <linux/platform_device.h>
+
+#include <drm/drm_drv.h>
 #include <drm/drm_print.h>
 
 #include "tidss_crtc.h"
        spin_unlock_irqrestore(&tidss->wait_lock, flags);
 }
 
-irqreturn_t tidss_irq_handler(int irq, void *arg)
+static irqreturn_t tidss_irq_handler(int irq, void *arg)
 {
        struct drm_device *ddev = (struct drm_device *)arg;
        struct tidss_device *tidss = to_tidss(ddev);
        spin_unlock_irqrestore(&tidss->wait_lock, flags);
 }
 
-void tidss_irq_preinstall(struct drm_device *ddev)
+static void tidss_irq_preinstall(struct drm_device *ddev)
 {
        struct tidss_device *tidss = to_tidss(ddev);
 
        tidss_runtime_put(tidss);
 }
 
-int tidss_irq_postinstall(struct drm_device *ddev)
+static void tidss_irq_postinstall(struct drm_device *ddev)
 {
        struct tidss_device *tidss = to_tidss(ddev);
        unsigned long flags;
        spin_unlock_irqrestore(&tidss->wait_lock, flags);
 
        tidss_runtime_put(tidss);
+}
+
+int tidss_irq_install(struct drm_device *ddev, unsigned int irq)
+{
+       int ret;
+
+       if (irq == IRQ_NOTCONNECTED)
+               return -ENOTCONN;
+
+       tidss_irq_preinstall(ddev);
+
+       ret = request_irq(irq, tidss_irq_handler, 0, ddev->driver->name, ddev);
+       if (ret)
+               return ret;
+
+       tidss_irq_postinstall(ddev);
 
        return 0;
 }
        tidss_runtime_get(tidss);
        dispc_set_irqenable(tidss->dispc, 0);
        tidss_runtime_put(tidss);
+
+       free_irq(tidss->irq, ddev);
 }
 
 void tidss_irq_enable_vblank(struct drm_crtc *crtc);
 void tidss_irq_disable_vblank(struct drm_crtc *crtc);
 
-void tidss_irq_preinstall(struct drm_device *ddev);
-int tidss_irq_postinstall(struct drm_device *ddev);
+int tidss_irq_install(struct drm_device *ddev, unsigned int irq);
 void tidss_irq_uninstall(struct drm_device *ddev);
-irqreturn_t tidss_irq_handler(int irq, void *arg);
 
 void tidss_irq_resume(struct tidss_device *tidss);