</para>
         <sect4>
           <title>Managed IRQ Registration</title>
-          <para>
-            Both the <function>drm_irq_install</function> and
-           <function>drm_irq_uninstall</function> functions get the device IRQ by
-           calling <function>drm_dev_to_irq</function>. This inline function will
-           call a bus-specific operation to retrieve the IRQ number. For platform
-           devices, <function>platform_get_irq</function>(..., 0) is used to
-           retrieve the IRQ number.
-          </para>
           <para>
             <function>drm_irq_install</function> starts by calling the
             <methodname>irq_preinstall</methodname> driver operation. The operation
             clearing all pending interrupt flags or disabling the interrupt.
           </para>
           <para>
-            The IRQ will then be requested by a call to
+            The passed-in IRQ will then be requested by a call to
             <function>request_irq</function>. If the DRIVER_IRQ_SHARED driver
             feature flag is set, a shared (IRQF_SHARED) IRQ handler will be
             requested.
 
        if (ret)
                goto err_kms;
 
-       ret = drm_irq_install(dev);
+       ret = drm_irq_install(dev, platform_get_irq(dev->platformdev, 0));
        if (ret)
                goto err_kms;
 
 
        }
 }
 
-static inline int drm_dev_to_irq(struct drm_device *dev)
-{
-       return dev->driver->bus->get_irq(dev);
-}
-
 /**
  * Install IRQ handler.
  *
  * \c irq_preinstall() and \c irq_postinstall() functions
  * before and after the installation.
  */
-int drm_irq_install(struct drm_device *dev)
+int drm_irq_install(struct drm_device *dev, int irq)
 {
-       int ret, irq;
+       int ret;
        unsigned long sh_flags = 0;
        char *irqname;
 
-       irq = drm_dev_to_irq(dev);
-
        if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
                return -EINVAL;
 
                    ctl->irq != irq)
                        return -EINVAL;
                mutex_lock(&dev->struct_mutex);
-               ret = drm_irq_install(dev);
+               ret = drm_irq_install(dev, irq);
                mutex_unlock(&dev->struct_mutex);
 
                return ret;
 
        PSB_WVDC32(0xFFFFFFFF, PSB_INT_MASK_R);
        spin_unlock_irqrestore(&dev_priv->irqmask_lock, irqflags);
 
-       drm_irq_install(dev);
+       drm_irq_install(dev, dev->pdev->irq);
 
        dev->vblank_disable_allowed = true;
        dev->max_vblank_count = 0xffffff; /* only 24 bits of frame count */
 
 
        intel_power_domains_init_hw(dev_priv);
 
-       ret = drm_irq_install(dev);
+       ret = drm_irq_install(dev, dev->pdev->irq);
        if (ret)
                goto cleanup_gem_stolen;
 
 
                mutex_unlock(&dev->struct_mutex);
 
                /* We need working interrupts for modeset enabling ... */
-               drm_irq_install(dev);
+               drm_irq_install(dev, dev->pdev->irq);
 
                intel_modeset_init_hw(dev);
 
                 * being false when they shouldn't be able to.
                 */
                drm_irq_uninstall(dev);
-               drm_irq_install(dev);
+               drm_irq_install(dev, dev->pdev->irq);
 
                /* rps/rc6 re-init is necessary to restore state lost after the
                 * reset and the re-install of drm irq. Skip for ironlake per
 
 
        BUG_ON(!list_empty(&dev_priv->gtt.base.active_list));
 
-       ret = drm_irq_install(dev);
+       ret = drm_irq_install(dev, dev->pdev->irq);
        if (ret)
                goto cleanup_ringbuffer;
        mutex_unlock(&dev->struct_mutex);
 
        }
 
        pm_runtime_get_sync(dev->dev);
-       ret = drm_irq_install(dev);
+       ret = drm_irq_install(dev, platform_get_irq(dev->platformdev, 0));
        pm_runtime_put_sync(dev->dev);
        if (ret < 0) {
                dev_err(dev->dev, "failed to install IRQ handler\n");
 
        atomic_set(&qdev->irq_received_cursor, 0);
        atomic_set(&qdev->irq_received_io_cmd, 0);
        qdev->irq_received_error = 0;
-       ret = drm_irq_install(qdev->ddev);
+       ret = drm_irq_install(qdev->ddev, qdev->ddev->pdev->irq);
        qdev->ram_header->int_mask = QXL_INTERRUPT_MASK;
        if (unlikely(ret != 0)) {
                DRM_ERROR("Failed installing irq: %d\n", ret);
 
        INIT_WORK(&rdev->reset_work, radeon_irq_reset_work_func);
 
        rdev->irq.installed = true;
-       r = drm_irq_install(rdev->ddev);
+       r = drm_irq_install(rdev->ddev, rdev->ddev->pdev->irq);
        if (r) {
                rdev->irq.installed = false;
                flush_work(&rdev->hotplug_work);
 
                goto done;
        }
 
-       ret = drm_irq_install(dev);
+       ret = drm_irq_install(dev, platform_get_irq(dev->platformdev, 0));
        if (ret < 0) {
                dev_err(&pdev->dev, "failed to install IRQ handler\n");
                goto done;
 
        }
 
        pm_runtime_get_sync(dev->dev);
-       ret = drm_irq_install(dev);
+       ret = drm_irq_install(dev, platform_get_irq(dev->platformdev, 0));
        pm_runtime_put_sync(dev->dev);
        if (ret < 0) {
                dev_err(dev->dev, "failed to install IRQ handler\n");
 
        }
 
        if (dev_priv->capabilities & SVGA_CAP_IRQMASK) {
-               ret = drm_irq_install(dev);
+               ret = drm_irq_install(dev, dev->pdev->irq);
                if (ret != 0) {
                        DRM_ERROR("Failed installing irq: %d\n", ret);
                        goto out_no_irq;
 
                                /* IRQ support (drm_irq.h) */
 extern int drm_control(struct drm_device *dev, void *data,
                       struct drm_file *file_priv);
-extern int drm_irq_install(struct drm_device *dev);
+extern int drm_irq_install(struct drm_device *dev, int irq);
 extern int drm_irq_uninstall(struct drm_device *dev);
 
 extern int drm_vblank_init(struct drm_device *dev, int num_crtcs);