1 files changed, 180 insertions, 137 deletions

diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c
index bf0a740122bf..403f44a1bf01 100644
--- a/drivers/char/drm/drm_fops.c
+++ b/drivers/char/drm/drm_fops.c
@@ -35,6 +35,7 @@
  */
 
 #include "drmP.h"
+#include "drm_sarea.h"
 #include <linux/poll.h>
 
 static int drm_open_helper(struct inode *inode, struct file *filp,
@@ -42,15 +43,21 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
 
 static int drm_setup(drm_device_t * dev)
 {
+        drm_local_map_t *map;
         int i;
         int ret;
 
-        if (dev->driver->presetup) {
-                ret = dev->driver->presetup(dev);
+        if (dev->driver->firstopen) {
+                ret = dev->driver->firstopen(dev);
                 if (ret != 0)
                         return ret;
         }
 
+        /* prebuild the SAREA */
+        i = drm_addmap(dev, 0, SAREA_MAX, _DRM_SHM, _DRM_CONTAINS_LOCK, &map);
+        if (i != 0)
+                return i;
+
         atomic_set(&dev->ioctl_count, 0);
         atomic_set(&dev->vma_count, 0);
         dev->buf_use = 0;
@@ -109,8 +116,6 @@ static int drm_setup(drm_device_t * dev)
          * drm_select_queue fails between the time the interrupt is
          * initialized and the time the queues are initialized.
          */
-        if (dev->driver->postsetup)
-                dev->driver->postsetup(dev);
 
         return 0;
 }
@@ -154,10 +159,168 @@ int drm_open(struct inode *inode, struct file *filp)
 
         return retcode;
 }
-
 EXPORT_SYMBOL(drm_open);
 
 /**
+ * File \c open operation.
+ *
+ * \param inode device inode.
+ * \param filp file pointer.
+ *
+ * Puts the dev->fops corresponding to the device minor number into
+ * \p filp, call the \c open method, and restore the file operations.
+ */
+int drm_stub_open(struct inode *inode, struct file *filp)
+{
+        drm_device_t *dev = NULL;
+        int minor = iminor(inode);
+        int err = -ENODEV;
+        struct file_operations *old_fops;
+
+        DRM_DEBUG("\n");
+
+        if (!((minor >= 0) && (minor < drm_cards_limit)))
+                return -ENODEV;
+
+        if (!drm_heads[minor])
+                return -ENODEV;
+
+        if (!(dev = drm_heads[minor]->dev))
+                return -ENODEV;
+
+        old_fops = filp->f_op;
+        filp->f_op = fops_get(&dev->driver->fops);
+        if (filp->f_op->open && (err = filp->f_op->open(inode, filp))) {
+                fops_put(filp->f_op);
+                filp->f_op = fops_get(old_fops);
+        }
+        fops_put(old_fops);
+
+        return err;
+}
+
+/**
+ * Check whether DRI will run on this CPU.
+ *
+ * \return non-zero if the DRI will run on this CPU, or zero otherwise.
+ */
+static int drm_cpu_valid(void)
+{
+#if defined(__i386__)
+        if (boot_cpu_data.x86 == 3)
+                return 0;       /* No cmpxchg on a 386 */
+#endif
+#if defined(__sparc__) && !defined(__sparc_v9__)
+        return 0;               /* No cmpxchg before v9 sparc. */
+#endif
+        return 1;
+}
+
+/**
+ * Called whenever a process opens /dev/drm.
+ *
+ * \param inode device inode.
+ * \param filp file pointer.
+ * \param dev device.
+ * \return zero on success or a negative number on failure.
+ *
+ * Creates and initializes a drm_file structure for the file private data in \p
+ * filp and add it into the double linked list in \p dev.
+ */
+static int drm_open_helper(struct inode *inode, struct file *filp,
+                           drm_device_t * dev)
+{
+        int minor = iminor(inode);
+        drm_file_t *priv;
+        int ret;
+
+        if (filp->f_flags & O_EXCL)
+                return -EBUSY;  /* No exclusive opens */
+        if (!drm_cpu_valid())
+                return -EINVAL;
+
+        DRM_DEBUG("pid = %d, minor = %d\n", current->pid, minor);
+
+        priv = drm_alloc(sizeof(*priv), DRM_MEM_FILES);
+        if (!priv)
+                return -ENOMEM;
+
+        memset(priv, 0, sizeof(*priv));
+        filp->private_data = priv;
+        priv->uid = current->euid;
+        priv->pid = current->pid;
+        priv->minor = minor;
+        priv->head = drm_heads[minor];
+        priv->ioctl_count = 0;
+        /* for compatibility root is always authenticated */
+        priv->authenticated = capable(CAP_SYS_ADMIN);
+        priv->lock_count = 0;
+
+        if (dev->driver->open) {
+                ret = dev->driver->open(dev, priv);
+                if (ret < 0)
+                        goto out_free;
+        }
+
+        down(&dev->struct_sem);
+        if (!dev->file_last) {
+                priv->next = NULL;
+                priv->prev = NULL;
+                dev->file_first = priv;
+                dev->file_last = priv;
+                /* first opener automatically becomes master */
+                priv->master = 1;
+        } else {
+                priv->next = NULL;
+                priv->prev = dev->file_last;
+                dev->file_last->next = priv;
+                dev->file_last = priv;
+        }
+        up(&dev->struct_sem);
+
+#ifdef __alpha__
+        /*
+         * Default the hose
+         */
+        if (!dev->hose) {
+                struct pci_dev *pci_dev;
+                pci_dev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, NULL);
+                if (pci_dev) {
+                        dev->hose = pci_dev->sysdata;
+                        pci_dev_put(pci_dev);
+                }
+                if (!dev->hose) {
+                        struct pci_bus *b = pci_bus_b(pci_root_buses.next);
+                        if (b)
+                                dev->hose = b->sysdata;
+                }
+        }
+#endif
+
+        return 0;
+      out_free:
+        drm_free(priv, sizeof(*priv), DRM_MEM_FILES);
+        filp->private_data = NULL;
+        return ret;
+}
+
+/** No-op. */
+int drm_fasync(int fd, struct file *filp, int on)
+{
+        drm_file_t *priv = filp->private_data;
+        drm_device_t *dev = priv->head->dev;
+        int retcode;
+
+        DRM_DEBUG("fd = %d, device = 0x%lx\n", fd,
+                  (long)old_encode_dev(priv->head->device));
+        retcode = fasync_helper(fd, filp, on, &dev->buf_async);
+        if (retcode < 0)
+                return retcode;
+        return 0;
+}
+EXPORT_SYMBOL(drm_fasync);
+
+/**
  * Release file.
  *
  * \param inode device inode
@@ -167,7 +330,7 @@ EXPORT_SYMBOL(drm_open);
  * If the hardware lock is held then free it, and take it again for the kernel
  * context since it's necessary to reclaim buffers. Unlink the file private
  * data from its list and free it. Decreases the open count and if it reaches
- * zero calls takedown().
+ * zero calls drm_lastclose().
  */
 int drm_release(struct inode *inode, struct file *filp)
 {
@@ -180,8 +343,8 @@ int drm_release(struct inode *inode, struct file *filp)
 
         DRM_DEBUG("open_count = %d\n", dev->open_count);
 
-        if (dev->driver->prerelease)
-                dev->driver->prerelease(dev, filp);
+        if (dev->driver->preclose)
+                dev->driver->preclose(dev, filp);
 
         /* ========================================================
          * Begin inline drm_release
@@ -197,8 +360,8 @@ int drm_release(struct inode *inode, struct file *filp)
                 DRM_DEBUG("File %p released, freeing lock for context %d\n",
                           filp, _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
 
-                if (dev->driver->release)
-                        dev->driver->release(dev, filp);
+                if (dev->driver->reclaim_buffers_locked)
+                        dev->driver->reclaim_buffers_locked(dev, filp);
 
                 drm_lock_free(dev, &dev->lock.hw_lock->lock,
                               _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
@@ -207,7 +370,7 @@ int drm_release(struct inode *inode, struct file *filp)
                    hardware at this point, possibly
                    processed via a callback to the X
                    server. */
-        } else if (dev->driver->release && priv->lock_count
+        } else if (dev->driver->reclaim_buffers_locked && priv->lock_count
                    && dev->lock.hw_lock) {
                 /* The lock is required to reclaim buffers */
                 DECLARE_WAITQUEUE(entry, current);
@@ -237,15 +400,14 @@ int drm_release(struct inode *inode, struct file *filp)
                 __set_current_state(TASK_RUNNING);
                 remove_wait_queue(&dev->lock.lock_queue, &entry);
                 if (!retcode) {
-                        if (dev->driver->release)
-                                dev->driver->release(dev, filp);
+                        dev->driver->reclaim_buffers_locked(dev, filp);
                         drm_lock_free(dev, &dev->lock.hw_lock->lock,
                                       DRM_KERNEL_CONTEXT);
                 }
         }
 
-        if (drm_core_check_feature(dev, DRIVER_HAVE_DMA)
-            && !dev->driver->release) {
+        if (drm_core_check_feature(dev, DRIVER_HAVE_DMA) &&
+            !dev->driver->reclaim_buffers_locked) {
                 dev->driver->reclaim_buffers(dev, filp);
         }
 
@@ -292,9 +454,8 @@ int drm_release(struct inode *inode, struct file *filp)
         }
         up(&dev->struct_sem);
 
-        if (dev->driver->free_filp_priv)
-                dev->driver->free_filp_priv(dev, priv);
-
+        if (dev->driver->postclose)
+                dev->driver->postclose(dev, priv);
         drm_free(priv, sizeof(*priv), DRM_MEM_FILES);
 
         /* ========================================================
@@ -313,7 +474,7 @@ int drm_release(struct inode *inode, struct file *filp)
                 }
                 spin_unlock(&dev->count_lock);
                 unlock_kernel();
-                return drm_takedown(dev);
+                return drm_lastclose(dev);
         }
         spin_unlock(&dev->count_lock);
 
@@ -321,129 +482,11 @@ int drm_release(struct inode *inode, struct file *filp)
 
         return retcode;
 }
-
 EXPORT_SYMBOL(drm_release);
 
-/**
- * Called whenever a process opens /dev/drm.
- *
- * \param inode device inode.
- * \param filp file pointer.
- * \param dev device.
- * \return zero on success or a negative number on failure.
- *
- * Creates and initializes a drm_file structure for the file private data in \p
- * filp and add it into the double linked list in \p dev.
- */
-static int drm_open_helper(struct inode *inode, struct file *filp,
-                           drm_device_t * dev)
-{
-        int minor = iminor(inode);
-        drm_file_t *priv;
-        int ret;
-
-        if (filp->f_flags & O_EXCL)
-                return -EBUSY;  /* No exclusive opens */
-        if (!drm_cpu_valid())
-                return -EINVAL;
-
-        DRM_DEBUG("pid = %d, minor = %d\n", current->pid, minor);
-
-        priv = drm_alloc(sizeof(*priv), DRM_MEM_FILES);
-        if (!priv)
-                return -ENOMEM;
-
-        memset(priv, 0, sizeof(*priv));
-        filp->private_data = priv;
-        priv->uid = current->euid;
-        priv->pid = current->pid;
-        priv->minor = minor;
-        priv->head = drm_heads[minor];
-        priv->ioctl_count = 0;
-        priv->authenticated = capable(CAP_SYS_ADMIN);
-        priv->lock_count = 0;
-
-        if (dev->driver->open_helper) {
-                ret = dev->driver->open_helper(dev, priv);
-                if (ret < 0)
-                        goto out_free;
-        }
-
-        down(&dev->struct_sem);
-        if (!dev->file_last) {
-                priv->next = NULL;
-                priv->prev = NULL;
-                dev->file_first = priv;
-                dev->file_last = priv;
-        } else {
-                priv->next = NULL;
-                priv->prev = dev->file_last;
-                dev->file_last->next = priv;
-                dev->file_last = priv;
-        }
-        up(&dev->struct_sem);
-
-#ifdef __alpha__
-        /*
-         * Default the hose
-         */
-        if (!dev->hose) {
-                struct pci_dev *pci_dev;
-                pci_dev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, NULL);
-                if (pci_dev) {
-                        dev->hose = pci_dev->sysdata;
-                        pci_dev_put(pci_dev);
-                }
-                if (!dev->hose) {
-                        struct pci_bus *b = pci_bus_b(pci_root_buses.next);
-                        if (b)
-                                dev->hose = b->sysdata;
-                }
-        }
-#endif
-
-        return 0;
-      out_free:
-        drm_free(priv, sizeof(*priv), DRM_MEM_FILES);
-        filp->private_data = NULL;
-        return ret;
-}
-
-/** No-op. */
-int drm_flush(struct file *filp)
-{
-        drm_file_t *priv = filp->private_data;
-        drm_device_t *dev = priv->head->dev;
-
-        DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n",
-                  current->pid, (long)old_encode_dev(priv->head->device),
-                  dev->open_count);
-        return 0;
-}
-
-EXPORT_SYMBOL(drm_flush);
-
-/** No-op. */
-int drm_fasync(int fd, struct file *filp, int on)
-{
-        drm_file_t *priv = filp->private_data;
-        drm_device_t *dev = priv->head->dev;
-        int retcode;
-
-        DRM_DEBUG("fd = %d, device = 0x%lx\n", fd,
-                  (long)old_encode_dev(priv->head->device));
-        retcode = fasync_helper(fd, filp, on, &dev->buf_async);
-        if (retcode < 0)
-                return retcode;
-        return 0;
-}
-
-EXPORT_SYMBOL(drm_fasync);
-
 /** No-op. */
 unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait)
 {
         return 0;
 }
-
 EXPORT_SYMBOL(drm_poll);