staging: vboxvideo: Use more drm_fb_helper functions

[linux.git] / drivers / staging / vboxvideo / vbox_drv.c

diff --git a/drivers/staging/vboxvideo/vbox_drv.c b/drivers/staging/vboxvideo/vbox_drv.c
index da92c493f1577ab7d35da20c73dd70f052fffc77..257030460fb620dd848977c971c9a2df7c4fcec4 100644 (file)
--- a/drivers/staging/vboxvideo/vbox_drv.c
+++ b/drivers/staging/vboxvideo/vbox_drv.c
@@ -49,132 +49,140 @@ static const struct pci_device_id pciidlist[] = {
 };
 MODULE_DEVICE_TABLE(pci, pciidlist);
 
+static struct drm_fb_helper_funcs vbox_fb_helper_funcs = {
+       .fb_probe = vboxfb_create,
+};
+
 static int vbox_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
-       struct drm_device *dev = NULL;
+       struct vbox_private *vbox;
        int ret = 0;
 
-       dev = drm_dev_alloc(&driver, &pdev->dev);
-       if (IS_ERR(dev)) {
-               ret = PTR_ERR(dev);
-               goto err_drv_alloc;
-       }
-       dev->pdev = pdev;
-       pci_set_drvdata(pdev, dev);
+       if (!vbox_check_supported(VBE_DISPI_ID_HGSMI))
+               return -ENODEV;
 
-       ret = vbox_driver_load(dev);
-       if (ret)
-               goto err_vbox_driver_load;
+       vbox = kzalloc(sizeof(*vbox), GFP_KERNEL);
+       if (!vbox)
+               return -ENOMEM;
 
-       ret = drm_dev_register(dev, 0);
-       if (ret)
-               goto err_drv_dev_register;
+       ret = drm_dev_init(&vbox->ddev, &driver, &pdev->dev);
+       if (ret) {
+               kfree(vbox);
+               return ret;
+       }
 
-       return ret;
+       vbox->ddev.pdev = pdev;
+       vbox->ddev.dev_private = vbox;
+       pci_set_drvdata(pdev, vbox);
+       mutex_init(&vbox->hw_mutex);
 
- err_drv_dev_register:
-       vbox_driver_unload(dev);
- err_vbox_driver_load:
-       drm_dev_put(dev);
- err_drv_alloc:
-       return ret;
-}
+       ret = pci_enable_device(pdev);
+       if (ret)
+               goto err_dev_put;
 
-static void vbox_pci_remove(struct pci_dev *pdev)
-{
-       struct drm_device *dev = pci_get_drvdata(pdev);
+       ret = vbox_hw_init(vbox);
+       if (ret)
+               goto err_pci_disable;
 
-       drm_dev_unregister(dev);
-       vbox_driver_unload(dev);
-       drm_dev_put(dev);
-}
+       ret = vbox_mm_init(vbox);
+       if (ret)
+               goto err_hw_fini;
 
-static int vbox_drm_freeze(struct drm_device *dev)
-{
-       struct vbox_private *vbox = dev->dev_private;
+       ret = vbox_mode_init(vbox);
+       if (ret)
+               goto err_mm_fini;
 
-       drm_kms_helper_poll_disable(dev);
+       ret = vbox_irq_init(vbox);
+       if (ret)
+               goto err_mode_fini;
 
-       pci_save_state(dev->pdev);
+       ret = drm_fb_helper_fbdev_setup(&vbox->ddev, &vbox->fb_helper,
+                                       &vbox_fb_helper_funcs, 32,
+                                       vbox->num_crtcs);
+       if (ret)
+               goto err_irq_fini;
 
-       drm_fb_helper_set_suspend_unlocked(&vbox->fbdev->helper, true);
+       ret = drm_dev_register(&vbox->ddev, 0);
+       if (ret)
+               goto err_fbdev_fini;
 
        return 0;
-}
-
-static int vbox_drm_thaw(struct drm_device *dev)
-{
-       struct vbox_private *vbox = dev->dev_private;
-
-       drm_mode_config_reset(dev);
-       drm_helper_resume_force_mode(dev);
-       drm_fb_helper_set_suspend_unlocked(&vbox->fbdev->helper, false);
 
-       return 0;
+err_fbdev_fini:
+       vbox_fbdev_fini(vbox);
+err_irq_fini:
+       vbox_irq_fini(vbox);
+err_mode_fini:
+       vbox_mode_fini(vbox);
+err_mm_fini:
+       vbox_mm_fini(vbox);
+err_hw_fini:
+       vbox_hw_fini(vbox);
+err_pci_disable:
+       pci_disable_device(pdev);
+err_dev_put:
+       drm_dev_put(&vbox->ddev);
+       return ret;
 }
 
-static int vbox_drm_resume(struct drm_device *dev)
+static void vbox_pci_remove(struct pci_dev *pdev)
 {
-       int ret;
-
-       if (pci_enable_device(dev->pdev))
-               return -EIO;
-
-       ret = vbox_drm_thaw(dev);
-       if (ret)
-               return ret;
-
-       drm_kms_helper_poll_enable(dev);
-
-       return 0;
+       struct vbox_private *vbox = pci_get_drvdata(pdev);
+
+       drm_dev_unregister(&vbox->ddev);
+       vbox_fbdev_fini(vbox);
+       vbox_irq_fini(vbox);
+       vbox_mode_fini(vbox);
+       vbox_mm_fini(vbox);
+       vbox_hw_fini(vbox);
+       drm_dev_put(&vbox->ddev);
 }
 
 static int vbox_pm_suspend(struct device *dev)
 {
-       struct pci_dev *pdev = to_pci_dev(dev);
-       struct drm_device *ddev = pci_get_drvdata(pdev);
+       struct vbox_private *vbox = dev_get_drvdata(dev);
        int error;
 
-       error = vbox_drm_freeze(ddev);
+       error = drm_mode_config_helper_suspend(&vbox->ddev);
        if (error)
                return error;
 
-       pci_disable_device(pdev);
-       pci_set_power_state(pdev, PCI_D3hot);
+       pci_save_state(vbox->ddev.pdev);
+       pci_disable_device(vbox->ddev.pdev);
+       pci_set_power_state(vbox->ddev.pdev, PCI_D3hot);
 
        return 0;
 }
 
 static int vbox_pm_resume(struct device *dev)
 {
-       struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev));
+       struct vbox_private *vbox = dev_get_drvdata(dev);
+
+       if (pci_enable_device(vbox->ddev.pdev))
+               return -EIO;
 
-       return vbox_drm_resume(ddev);
+       return drm_mode_config_helper_resume(&vbox->ddev);
 }
 
 static int vbox_pm_freeze(struct device *dev)
 {
-       struct pci_dev *pdev = to_pci_dev(dev);
-       struct drm_device *ddev = pci_get_drvdata(pdev);
-
-       if (!ddev || !ddev->dev_private)
-               return -ENODEV;
+       struct vbox_private *vbox = dev_get_drvdata(dev);
 
-       return vbox_drm_freeze(ddev);
+       return drm_mode_config_helper_suspend(&vbox->ddev);
 }
 
 static int vbox_pm_thaw(struct device *dev)
 {
-       struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev));
+       struct vbox_private *vbox = dev_get_drvdata(dev);
 
-       return vbox_drm_thaw(ddev);
+       return drm_mode_config_helper_resume(&vbox->ddev);
 }
 
 static int vbox_pm_poweroff(struct device *dev)
 {
-       struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev));
+       struct vbox_private *vbox = dev_get_drvdata(dev);
 
-       return vbox_drm_freeze(ddev);
+       return drm_mode_config_helper_suspend(&vbox->ddev);
 }
 
 static const struct dev_pm_ops vbox_pm_ops = {
@@ -252,10 +260,10 @@ static void vbox_master_drop(struct drm_device *dev, struct drm_file *file_priv)
 static struct drm_driver driver = {
        .driver_features =
            DRIVER_MODESET | DRIVER_GEM | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED |
-           DRIVER_PRIME,
+           DRIVER_PRIME | DRIVER_ATOMIC,
        .dev_priv_size = 0,
 
-       .lastclose = vbox_driver_lastclose,
+       .lastclose = drm_fb_helper_lastclose,
        .master_set = vbox_master_set,
        .master_drop = vbox_master_drop,