Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 116 insertions, 22 deletions

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
index a96ed6d9d010..96949b93d920 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
@@ -260,13 +260,11 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
         idr_init(&dev_priv->context_idr);
         idr_init(&dev_priv->surface_idr);
         idr_init(&dev_priv->stream_idr);
-        ida_init(&dev_priv->gmr_ida);
         mutex_init(&dev_priv->init_mutex);
         init_waitqueue_head(&dev_priv->fence_queue);
         init_waitqueue_head(&dev_priv->fifo_queue);
         atomic_set(&dev_priv->fence_queue_waiters, 0);
         atomic_set(&dev_priv->fifo_queue_waiters, 0);
-        INIT_LIST_HEAD(&dev_priv->gmr_lru);
 
         dev_priv->io_start = pci_resource_start(dev->pdev, 0);
         dev_priv->vram_start = pci_resource_start(dev->pdev, 1);
@@ -341,6 +339,14 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
                 goto out_err2;
         }
 
+        dev_priv->has_gmr = true;
+        if (ttm_bo_init_mm(&dev_priv->bdev, VMW_PL_GMR,
+                           dev_priv->max_gmr_ids) != 0) {
+                DRM_INFO("No GMR memory available. "
+                         "Graphics memory resources are very limited.\n");
+                dev_priv->has_gmr = false;
+        }
+
         dev_priv->mmio_mtrr = drm_mtrr_add(dev_priv->mmio_start,
                                            dev_priv->mmio_size, DRM_MTRR_WC);
 
@@ -440,13 +446,14 @@ out_err4:
 out_err3:
         drm_mtrr_del(dev_priv->mmio_mtrr, dev_priv->mmio_start,
                      dev_priv->mmio_size, DRM_MTRR_WC);
+        if (dev_priv->has_gmr)
+                (void) ttm_bo_clean_mm(&dev_priv->bdev, VMW_PL_GMR);
         (void)ttm_bo_clean_mm(&dev_priv->bdev, TTM_PL_VRAM);
 out_err2:
         (void)ttm_bo_device_release(&dev_priv->bdev);
 out_err1:
         vmw_ttm_global_release(dev_priv);
 out_err0:
-        ida_destroy(&dev_priv->gmr_ida);
         idr_destroy(&dev_priv->surface_idr);
         idr_destroy(&dev_priv->context_idr);
         idr_destroy(&dev_priv->stream_idr);
@@ -478,10 +485,11 @@ static int vmw_driver_unload(struct drm_device *dev)
         iounmap(dev_priv->mmio_virt);
         drm_mtrr_del(dev_priv->mmio_mtrr, dev_priv->mmio_start,
                      dev_priv->mmio_size, DRM_MTRR_WC);
+        if (dev_priv->has_gmr)
+                (void)ttm_bo_clean_mm(&dev_priv->bdev, VMW_PL_GMR);
         (void)ttm_bo_clean_mm(&dev_priv->bdev, TTM_PL_VRAM);
         (void)ttm_bo_device_release(&dev_priv->bdev);
         vmw_ttm_global_release(dev_priv);
-        ida_destroy(&dev_priv->gmr_ida);
         idr_destroy(&dev_priv->surface_idr);
         idr_destroy(&dev_priv->context_idr);
         idr_destroy(&dev_priv->stream_idr);
@@ -597,6 +605,8 @@ static void vmw_lastclose(struct drm_device *dev)
 static void vmw_master_init(struct vmw_master *vmaster)
 {
         ttm_lock_init(&vmaster->lock);
+        INIT_LIST_HEAD(&vmaster->fb_surf);
+        mutex_init(&vmaster->fb_surf_mutex);
 }
 
 static int vmw_master_create(struct drm_device *dev,
@@ -608,7 +618,7 @@ static int vmw_master_create(struct drm_device *dev,
         if (unlikely(vmaster == NULL))
                 return -ENOMEM;
 
-        ttm_lock_init(&vmaster->lock);
+        vmw_master_init(vmaster);
         ttm_lock_set_kill(&vmaster->lock, true, SIGTERM);
         master->driver_priv = vmaster;
 
@@ -699,6 +709,7 @@ static void vmw_master_drop(struct drm_device *dev,
 
         vmw_fp->locked_master = drm_master_get(file_priv->master);
         ret = ttm_vt_lock(&vmaster->lock, false, vmw_fp->tfile);
+        vmw_kms_idle_workqueues(vmaster);
 
         if (unlikely((ret != 0))) {
                 DRM_ERROR("Unable to lock TTM at VT switch.\n");
@@ -751,15 +762,16 @@ static int vmwgfx_pm_notifier(struct notifier_block *nb, unsigned long val,
                  * Buffer contents is moved to swappable memory.
                  */
                 ttm_bo_swapout_all(&dev_priv->bdev);
+
                 break;
         case PM_POST_HIBERNATION:
         case PM_POST_SUSPEND:
+        case PM_POST_RESTORE:
                 ttm_suspend_unlock(&vmaster->lock);
+
                 break;
         case PM_RESTORE_PREPARE:
                 break;
-        case PM_POST_RESTORE:
-                break;
         default:
                 break;
         }
@@ -770,21 +782,98 @@ static int vmwgfx_pm_notifier(struct notifier_block *nb, unsigned long val,
  * These might not be needed with the virtual SVGA device.
  */
 
-int vmw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
+static int vmw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
 {
+        struct drm_device *dev = pci_get_drvdata(pdev);
+        struct vmw_private *dev_priv = vmw_priv(dev);
+
+        if (dev_priv->num_3d_resources != 0) {
+                DRM_INFO("Can't suspend or hibernate "
+                         "while 3D resources are active.\n");
+                return -EBUSY;
+        }
+
         pci_save_state(pdev);
         pci_disable_device(pdev);
         pci_set_power_state(pdev, PCI_D3hot);
         return 0;
 }
 
-int vmw_pci_resume(struct pci_dev *pdev)
+static int vmw_pci_resume(struct pci_dev *pdev)
 {
         pci_set_power_state(pdev, PCI_D0);
         pci_restore_state(pdev);
         return pci_enable_device(pdev);
 }
 
+static int vmw_pm_suspend(struct device *kdev)
+{
+        struct pci_dev *pdev = to_pci_dev(kdev);
+        struct pm_message dummy;
+
+        dummy.event = 0;
+
+        return vmw_pci_suspend(pdev, dummy);
+}
+
+static int vmw_pm_resume(struct device *kdev)
+{
+        struct pci_dev *pdev = to_pci_dev(kdev);
+
+        return vmw_pci_resume(pdev);
+}
+
+static int vmw_pm_prepare(struct device *kdev)
+{
+        struct pci_dev *pdev = to_pci_dev(kdev);
+        struct drm_device *dev = pci_get_drvdata(pdev);
+        struct vmw_private *dev_priv = vmw_priv(dev);
+
+        /**
+         * Release 3d reference held by fbdev and potentially
+         * stop fifo.
+         */
+        dev_priv->suspended = true;
+        if (dev_priv->enable_fb)
+                vmw_3d_resource_dec(dev_priv);
+
+        if (dev_priv->num_3d_resources != 0) {
+
+                DRM_INFO("Can't suspend or hibernate "
+                         "while 3D resources are active.\n");
+
+                if (dev_priv->enable_fb)
+                        vmw_3d_resource_inc(dev_priv);
+                dev_priv->suspended = false;
+                return -EBUSY;
+        }
+
+        return 0;
+}
+
+static void vmw_pm_complete(struct device *kdev)
+{
+        struct pci_dev *pdev = to_pci_dev(kdev);
+        struct drm_device *dev = pci_get_drvdata(pdev);
+        struct vmw_private *dev_priv = vmw_priv(dev);
+
+        /**
+         * Reclaim 3d reference held by fbdev and potentially
+         * start fifo.
+         */
+        if (dev_priv->enable_fb)
+                vmw_3d_resource_inc(dev_priv);
+
+        dev_priv->suspended = false;
+}
+
+static const struct dev_pm_ops vmw_pm_ops = {
+        .prepare = vmw_pm_prepare,
+        .complete = vmw_pm_complete,
+        .suspend = vmw_pm_suspend,
+        .resume = vmw_pm_resume,
+};
+
 static struct drm_driver driver = {
         .driver_features = DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED |
         DRIVER_MODESET,
@@ -798,8 +887,6 @@ static struct drm_driver driver = {
         .irq_handler = vmw_irq_handler,
         .get_vblank_counter = vmw_get_vblank_counter,
         .reclaim_buffers_locked = NULL,
-        .get_map_ofs = drm_core_get_map_ofs,
-        .get_reg_ofs = drm_core_get_reg_ofs,
         .ioctls = vmw_ioctls,
         .num_ioctls = DRM_ARRAY_SIZE(vmw_ioctls),
         .dma_quiescent = NULL,  /*vmw_dma_quiescent, */
@@ -820,15 +907,8 @@ static struct drm_driver driver = {
 #if defined(CONFIG_COMPAT)
                  .compat_ioctl = drm_compat_ioctl,
 #endif
-                 },
-        .pci_driver = {
-                       .name = VMWGFX_DRIVER_NAME,
-                       .id_table = vmw_pci_id_list,
-                       .probe = vmw_probe,
-                       .remove = vmw_remove,
-                       .suspend = vmw_pci_suspend,
-                       .resume = vmw_pci_resume
-                       },
+                 .llseek = noop_llseek,
+        },
         .name = VMWGFX_DRIVER_NAME,
         .desc = VMWGFX_DRIVER_DESC,
         .date = VMWGFX_DRIVER_DATE,
@@ -837,6 +917,16 @@ static struct drm_driver driver = {
         .patchlevel = VMWGFX_DRIVER_PATCHLEVEL
 };
 
+static struct pci_driver vmw_pci_driver = {
+        .name = VMWGFX_DRIVER_NAME,
+        .id_table = vmw_pci_id_list,
+        .probe = vmw_probe,
+        .remove = vmw_remove,
+        .driver = {
+                .pm = &vmw_pm_ops
+        }
+};
+
 static int vmw_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
         return drm_get_pci_dev(pdev, ent, &driver);
@@ -845,7 +935,7 @@ static int vmw_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 static int __init vmwgfx_init(void)
 {
         int ret;
-        ret = drm_init(&driver);
+        ret = drm_pci_init(&driver, &vmw_pci_driver);
         if (ret)
                 DRM_ERROR("Failed initializing DRM.\n");
         return ret;
@@ -853,7 +943,7 @@ static int __init vmwgfx_init(void)
 
 static void __exit vmwgfx_exit(void)
 {
-        drm_exit(&driver);
+        drm_pci_exit(&driver, &vmw_pci_driver);
 }
 
 module_init(vmwgfx_init);
@@ -862,3 +952,7 @@ module_exit(vmwgfx_exit);
 MODULE_AUTHOR("VMware Inc. and others");
 MODULE_DESCRIPTION("Standalone drm driver for the VMware SVGA device");
 MODULE_LICENSE("GPL and additional rights");
+MODULE_VERSION(__stringify(VMWGFX_DRIVER_MAJOR) "."
+               __stringify(VMWGFX_DRIVER_MINOR) "."
+               __stringify(VMWGFX_DRIVER_PATCHLEVEL) "."
+               "0");