1 files changed, 242 insertions, 120 deletions

diff --git a/drivers/gpu/drm/drm_stub.c b/drivers/gpu/drm/drm_stub.c
index 39d864576be4..c200136a5d8e 100644
--- a/drivers/gpu/drm/drm_stub.c
+++ b/drivers/gpu/drm/drm_stub.c
@@ -254,81 +254,21 @@ int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
         return 0;
 }
 
-int drm_fill_in_dev(struct drm_device *dev,
-                           const struct pci_device_id *ent,
-                           struct drm_driver *driver)
-{
-        int retcode;
-
-        INIT_LIST_HEAD(&dev->filelist);
-        INIT_LIST_HEAD(&dev->ctxlist);
-        INIT_LIST_HEAD(&dev->vmalist);
-        INIT_LIST_HEAD(&dev->maplist);
-        INIT_LIST_HEAD(&dev->vblank_event_list);
-
-        spin_lock_init(&dev->count_lock);
-        spin_lock_init(&dev->event_lock);
-        mutex_init(&dev->struct_mutex);
-        mutex_init(&dev->ctxlist_mutex);
-
-        if (drm_ht_create(&dev->map_hash, 12)) {
-                return -ENOMEM;
-        }
-
-        /* the DRM has 6 basic counters */
-        dev->counters = 6;
-        dev->types[0] = _DRM_STAT_LOCK;
-        dev->types[1] = _DRM_STAT_OPENS;
-        dev->types[2] = _DRM_STAT_CLOSES;
-        dev->types[3] = _DRM_STAT_IOCTLS;
-        dev->types[4] = _DRM_STAT_LOCKS;
-        dev->types[5] = _DRM_STAT_UNLOCKS;
-
-        dev->driver = driver;
-
-        if (dev->driver->bus->agp_init) {
-                retcode = dev->driver->bus->agp_init(dev);
-                if (retcode)
-                        goto error_out_unreg;
-        }
-
-
-
-        retcode = drm_ctxbitmap_init(dev);
-        if (retcode) {
-                DRM_ERROR("Cannot allocate memory for context bitmap.\n");
-                goto error_out_unreg;
-        }
-
-        if (driver->driver_features & DRIVER_GEM) {
-                retcode = drm_gem_init(dev);
-                if (retcode) {
-                        DRM_ERROR("Cannot initialize graphics execution "
-                                  "manager (GEM)\n");
-                        goto error_out_unreg;
-                }
-        }
-
-        return 0;
-
-      error_out_unreg:
-        drm_lastclose(dev);
-        return retcode;
-}
-EXPORT_SYMBOL(drm_fill_in_dev);
-
-
 /**
- * Get a secondary minor number.
+ * drm_get_minor - Allocate and register new DRM minor
+ * @dev: DRM device
+ * @minor: Pointer to where new minor is stored
+ * @type: Type of minor
  *
- * \param dev device data structure
- * \param sec-minor structure to hold the assigned minor
- * \return negative number on failure.
+ * Allocate a new minor of the given type and register it. A pointer to the new
+ * minor is returned in @minor.
+ * Caller must hold the global DRM mutex.
  *
- * Search an empty entry and initialize it to the given parameters. This
- * routines assigns minor numbers to secondary heads of multi-headed cards
+ * RETURNS:
+ * 0 on success, negative error code on failure.
  */
-int drm_get_minor(struct drm_device *dev, struct drm_minor **minor, int type)
+static int drm_get_minor(struct drm_device *dev, struct drm_minor **minor,
+                         int type)
 {
         struct drm_minor *new_minor;
         int ret;
@@ -385,37 +325,48 @@ err_idr:
         *minor = NULL;
         return ret;
 }
-EXPORT_SYMBOL(drm_get_minor);
 
 /**
- * Put a secondary minor number.
+ * drm_unplug_minor - Unplug DRM minor
+ * @minor: Minor to unplug
  *
- * \param sec_minor - structure to be released
- * \return always zero
+ * Unplugs the given DRM minor but keeps the object. So after this returns,
+ * minor->dev is still valid so existing open-files can still access it to get
+ * device information from their drm_file ojects.
+ * If the minor is already unplugged or if @minor is NULL, nothing is done.
+ * The global DRM mutex must be held by the caller.
  */
-int drm_put_minor(struct drm_minor **minor_p)
+static void drm_unplug_minor(struct drm_minor *minor)
 {
-        struct drm_minor *minor = *minor_p;
-
-        DRM_DEBUG("release secondary minor %d\n", minor->index);
+        if (!minor || !device_is_registered(minor->kdev))
+                return;
 
 #if defined(CONFIG_DEBUG_FS)
         drm_debugfs_cleanup(minor);
 #endif
 
         drm_sysfs_device_remove(minor);
-
         idr_remove(&drm_minors_idr, minor->index);
-
-        kfree(minor);
-        *minor_p = NULL;
-        return 0;
 }
-EXPORT_SYMBOL(drm_put_minor);
 
-static void drm_unplug_minor(struct drm_minor *minor)
+/**
+ * drm_put_minor - Destroy DRM minor
+ * @minor: Minor to destroy
+ *
+ * This calls drm_unplug_minor() on the given minor and then frees it. Nothing
+ * is done if @minor is NULL. It is fine to call this on already unplugged
+ * minors.
+ * The global DRM mutex must be held by the caller.
+ */
+static void drm_put_minor(struct drm_minor *minor)
 {
-        drm_sysfs_device_remove(minor);
+        if (!minor)
+                return;
+
+        DRM_DEBUG("release secondary minor %d\n", minor->index);
+
+        drm_unplug_minor(minor);
+        kfree(minor);
 }
 
 /**
@@ -427,66 +378,237 @@ static void drm_unplug_minor(struct drm_minor *minor)
  */
 void drm_put_dev(struct drm_device *dev)
 {
-        struct drm_driver *driver;
-        struct drm_map_list *r_list, *list_temp;
-
         DRM_DEBUG("\n");
 
         if (!dev) {
                 DRM_ERROR("cleanup called no dev\n");
                 return;
         }
-        driver = dev->driver;
 
-        drm_lastclose(dev);
+        drm_dev_unregister(dev);
+        drm_dev_free(dev);
+}
+EXPORT_SYMBOL(drm_put_dev);
 
-        if (dev->driver->unload)
-                dev->driver->unload(dev);
+void drm_unplug_dev(struct drm_device *dev)
+{
+        /* for a USB device */
+        if (drm_core_check_feature(dev, DRIVER_MODESET))
+                drm_unplug_minor(dev->control);
+        if (dev->render)
+                drm_unplug_minor(dev->render);
+        drm_unplug_minor(dev->primary);
 
-        if (dev->driver->bus->agp_destroy)
-                dev->driver->bus->agp_destroy(dev);
+        mutex_lock(&drm_global_mutex);
 
-        drm_vblank_cleanup(dev);
+        drm_device_set_unplugged(dev);
 
-        list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head)
-                drm_rmmap(dev, r_list->map);
-        drm_ht_remove(&dev->map_hash);
+        if (dev->open_count == 0) {
+                drm_put_dev(dev);
+        }
+        mutex_unlock(&drm_global_mutex);
+}
+EXPORT_SYMBOL(drm_unplug_dev);
 
-        drm_ctxbitmap_cleanup(dev);
+/**
+ * drm_dev_alloc - Allocate new drm device
+ * @driver: DRM driver to allocate device for
+ * @parent: Parent device object
+ *
+ * Allocate and initialize a new DRM device. No device registration is done.
+ * Call drm_dev_register() to advertice the device to user space and register it
+ * with other core subsystems.
+ *
+ * RETURNS:
+ * Pointer to new DRM device, or NULL if out of memory.
+ */
+struct drm_device *drm_dev_alloc(struct drm_driver *driver,
+                                 struct device *parent)
+{
+        struct drm_device *dev;
+        int ret;
 
-        if (drm_core_check_feature(dev, DRIVER_MODESET))
-                drm_put_minor(&dev->control);
+        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+        if (!dev)
+                return NULL;
 
-        if (dev->render)
-                drm_put_minor(&dev->render);
+        dev->dev = parent;
+        dev->driver = driver;
 
-        if (driver->driver_features & DRIVER_GEM)
+        INIT_LIST_HEAD(&dev->filelist);
+        INIT_LIST_HEAD(&dev->ctxlist);
+        INIT_LIST_HEAD(&dev->vmalist);
+        INIT_LIST_HEAD(&dev->maplist);
+        INIT_LIST_HEAD(&dev->vblank_event_list);
+
+        spin_lock_init(&dev->count_lock);
+        spin_lock_init(&dev->event_lock);
+        mutex_init(&dev->struct_mutex);
+        mutex_init(&dev->ctxlist_mutex);
+
+        if (drm_ht_create(&dev->map_hash, 12))
+                goto err_free;
+
+        ret = drm_ctxbitmap_init(dev);
+        if (ret) {
+                DRM_ERROR("Cannot allocate memory for context bitmap.\n");
+                goto err_ht;
+        }
+
+        if (driver->driver_features & DRIVER_GEM) {
+                ret = drm_gem_init(dev);
+                if (ret) {
+                        DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n");
+                        goto err_ctxbitmap;
+                }
+        }
+
+        return dev;
+
+err_ctxbitmap:
+        drm_ctxbitmap_cleanup(dev);
+err_ht:
+        drm_ht_remove(&dev->map_hash);
+err_free:
+        kfree(dev);
+        return NULL;
+}
+EXPORT_SYMBOL(drm_dev_alloc);
+
+/**
+ * drm_dev_free - Free DRM device
+ * @dev: DRM device to free
+ *
+ * Free a DRM device that has previously been allocated via drm_dev_alloc().
+ * You must not use kfree() instead or you will leak memory.
+ *
+ * This must not be called once the device got registered. Use drm_put_dev()
+ * instead, which then calls drm_dev_free().
+ */
+void drm_dev_free(struct drm_device *dev)
+{
+        drm_put_minor(dev->control);
+        drm_put_minor(dev->render);
+        drm_put_minor(dev->primary);
+
+        if (dev->driver->driver_features & DRIVER_GEM)
                 drm_gem_destroy(dev);
 
-        drm_put_minor(&dev->primary);
+        drm_ctxbitmap_cleanup(dev);
+        drm_ht_remove(&dev->map_hash);
 
-        list_del(&dev->driver_item);
         kfree(dev->devname);
         kfree(dev);
 }
-EXPORT_SYMBOL(drm_put_dev);
+EXPORT_SYMBOL(drm_dev_free);
 
-void drm_unplug_dev(struct drm_device *dev)
+/**
+ * drm_dev_register - Register DRM device
+ * @dev: Device to register
+ *
+ * Register the DRM device @dev with the system, advertise device to user-space
+ * and start normal device operation. @dev must be allocated via drm_dev_alloc()
+ * previously.
+ *
+ * Never call this twice on any device!
+ *
+ * RETURNS:
+ * 0 on success, negative error code on failure.
+ */
+int drm_dev_register(struct drm_device *dev, unsigned long flags)
 {
-        /* for a USB device */
-        if (drm_core_check_feature(dev, DRIVER_MODESET))
-                drm_unplug_minor(dev->control);
-        if (dev->render)
-                drm_unplug_minor(dev->render);
-        drm_unplug_minor(dev->primary);
+        int ret;
 
         mutex_lock(&drm_global_mutex);
 
-        drm_device_set_unplugged(dev);
+        if (dev->driver->bus->agp_init) {
+                ret = dev->driver->bus->agp_init(dev);
+                if (ret)
+                        goto out_unlock;
+        }
 
-        if (dev->open_count == 0) {
-                drm_put_dev(dev);
+        if (drm_core_check_feature(dev, DRIVER_MODESET)) {
+                ret = drm_get_minor(dev, &dev->control, DRM_MINOR_CONTROL);
+                if (ret)
+                        goto err_agp;
+        }
+
+        if (drm_core_check_feature(dev, DRIVER_RENDER) && drm_rnodes) {
+                ret = drm_get_minor(dev, &dev->render, DRM_MINOR_RENDER);
+                if (ret)
+                        goto err_control_node;
+        }
+
+        ret = drm_get_minor(dev, &dev->primary, DRM_MINOR_LEGACY);
+        if (ret)
+                goto err_render_node;
+
+        if (dev->driver->load) {
+                ret = dev->driver->load(dev, flags);
+                if (ret)
+                        goto err_primary_node;
         }
+
+        /* setup grouping for legacy outputs */
+        if (drm_core_check_feature(dev, DRIVER_MODESET)) {
+                ret = drm_mode_group_init_legacy_group(dev,
+                                &dev->primary->mode_group);
+                if (ret)
+                        goto err_unload;
+        }
+
+        list_add_tail(&dev->driver_item, &dev->driver->device_list);
+
+        ret = 0;
+        goto out_unlock;
+
+err_unload:
+        if (dev->driver->unload)
+                dev->driver->unload(dev);
+err_primary_node:
+        drm_put_minor(dev->primary);
+err_render_node:
+        drm_put_minor(dev->render);
+err_control_node:
+        drm_put_minor(dev->control);
+err_agp:
+        if (dev->driver->bus->agp_destroy)
+                dev->driver->bus->agp_destroy(dev);
+out_unlock:
         mutex_unlock(&drm_global_mutex);
+        return ret;
 }
-EXPORT_SYMBOL(drm_unplug_dev);
+EXPORT_SYMBOL(drm_dev_register);
+
+/**
+ * drm_dev_unregister - Unregister DRM device
+ * @dev: Device to unregister
+ *
+ * Unregister the DRM device from the system. This does the reverse of
+ * drm_dev_register() but does not deallocate the device. The caller must call
+ * drm_dev_free() to free all resources.
+ */
+void drm_dev_unregister(struct drm_device *dev)
+{
+        struct drm_map_list *r_list, *list_temp;
+
+        drm_lastclose(dev);
+
+        if (dev->driver->unload)
+                dev->driver->unload(dev);
+
+        if (dev->driver->bus->agp_destroy)
+                dev->driver->bus->agp_destroy(dev);
+
+        drm_vblank_cleanup(dev);
+
+        list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head)
+                drm_rmmap(dev, r_list->map);
+
+        drm_unplug_minor(dev->control);
+        drm_unplug_minor(dev->render);
+        drm_unplug_minor(dev->primary);
+
+        list_del(&dev->driver_item);
+}
+EXPORT_SYMBOL(drm_dev_unregister);