drm: Replace DRM_IOCTL_ARGS with (dev, data, file_priv) and remove DRM_DEVICE.

[deliverable/linux.git] / drivers / char / drm / drm_fops.c

diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c
index 7bc51bac450d70210fee213275536148ebc8654b..f383fc37190c1a1d2a3a18396adda4d130a6b3f4 100644 (file)
--- a/drivers/char/drm/drm_fops.c
+++ b/drivers/char/drm/drm_fops.c
@@ -242,6 +242,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
 
        memset(priv, 0, sizeof(*priv));
        filp->private_data = priv;
+       priv->filp = filp;
        priv->uid = current->euid;
        priv->pid = current->pid;
        priv->minor = minor;
@@ -312,7 +313,7 @@ EXPORT_SYMBOL(drm_fasync);
  * Release file.
  *
  * \param inode device inode
- * \param filp file pointer.
+ * \param file_priv DRM file private.
  * \return zero on success or a negative number on failure.
  *
  * If the hardware lock is held then free it, and take it again for the kernel
@@ -322,29 +323,28 @@ EXPORT_SYMBOL(drm_fasync);
  */
 int drm_release(struct inode *inode, struct file *filp)
 {
-       struct drm_file *priv = filp->private_data;
-       struct drm_device *dev;
+       struct drm_file *file_priv = filp->private_data;
+       struct drm_device *dev = file_priv->head->dev;
        int retcode = 0;
 
        lock_kernel();
-       dev = priv->head->dev;
 
        DRM_DEBUG("open_count = %d\n", dev->open_count);
 
        if (dev->driver->preclose)
-               dev->driver->preclose(dev, filp);
+               dev->driver->preclose(dev, file_priv);
 
        /* ========================================================
         * Begin inline drm_release
         */
 
        DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n",
-                 current->pid, (long)old_encode_dev(priv->head->device),
+                 current->pid, (long)old_encode_dev(file_priv->head->device),
                  dev->open_count);
 
        if (dev->driver->reclaim_buffers_locked && dev->lock.hw_lock) {
-               if (drm_i_have_hw_lock(filp)) {
-                       dev->driver->reclaim_buffers_locked(dev, filp);
+               if (drm_i_have_hw_lock(dev, file_priv)) {
+                       dev->driver->reclaim_buffers_locked(dev, file_priv);
                } else {
                        unsigned long _end=jiffies + 3*DRM_HZ;
                        int locked = 0;
@@ -370,7 +370,7 @@ int drm_release(struct inode *inode, struct file *filp)
                                          "\tI will go on reclaiming the buffers anyway.\n");
                        }
 
-                       dev->driver->reclaim_buffers_locked(dev, filp);
+                       dev->driver->reclaim_buffers_locked(dev, file_priv);
                        drm_idlelock_release(&dev->lock);
                }
        }
@@ -378,12 +378,12 @@ int drm_release(struct inode *inode, struct file *filp)
        if (dev->driver->reclaim_buffers_idlelocked && dev->lock.hw_lock) {
 
                drm_idlelock_take(&dev->lock);
-               dev->driver->reclaim_buffers_idlelocked(dev, filp);
+               dev->driver->reclaim_buffers_idlelocked(dev, file_priv);
                drm_idlelock_release(&dev->lock);
 
        }
 
-       if (drm_i_have_hw_lock(filp)) {
+       if (drm_i_have_hw_lock(dev, file_priv)) {
                DRM_DEBUG("File %p released, freeing lock for context %d\n",
                          filp, _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
 
@@ -394,7 +394,7 @@ int drm_release(struct inode *inode, struct file *filp)
 
        if (drm_core_check_feature(dev, DRIVER_HAVE_DMA) &&
            !dev->driver->reclaim_buffers_locked) {
-               dev->driver->reclaim_buffers(dev, filp);
+               dev->driver->reclaim_buffers(dev, file_priv);
        }
 
        drm_fasync(-1, filp, 0);
@@ -404,7 +404,7 @@ int drm_release(struct inode *inode, struct file *filp)
                struct drm_ctx_list *pos, *n;
 
                list_for_each_entry_safe(pos, n, &dev->ctxlist, head) {
-                       if (pos->tag == priv &&
+                       if (pos->tag == file_priv &&
                            pos->handle != DRM_KERNEL_CONTEXT) {
                                if (dev->driver->context_dtor)
                                        dev->driver->context_dtor(dev,
@@ -421,18 +421,18 @@ int drm_release(struct inode *inode, struct file *filp)
        mutex_unlock(&dev->ctxlist_mutex);
 
        mutex_lock(&dev->struct_mutex);
-       if (priv->remove_auth_on_close == 1) {
+       if (file_priv->remove_auth_on_close == 1) {
                struct drm_file *temp;
 
                list_for_each_entry(temp, &dev->filelist, lhead)
                        temp->authenticated = 0;
        }
-       list_del(&priv->lhead);
+       list_del(&file_priv->lhead);
        mutex_unlock(&dev->struct_mutex);
 
        if (dev->driver->postclose)
-               dev->driver->postclose(dev, priv);
-       drm_free(priv, sizeof(*priv), DRM_MEM_FILES);
+               dev->driver->postclose(dev, file_priv);
+       drm_free(file_priv, sizeof(*file_priv), DRM_MEM_FILES);
 
        /* ========================================================
         * End inline drm_release