drm/tegra: Move subdevice infrastructure to host1x

The Tegra DRM driver currently uses some infrastructure to defer the DRM
core initialization until all required devices have registered. The same
infrastructure can potentially be used by any other driver that requires
more than a single sub-device of the host1x module.

Make the infrastructure more generic and keep only the DRM specific code
in the DRM part of the driver. Eventually this will make it easy to move
the DRM driver part back to the DRM subsystem.

Signed-off-by: Thierry Reding <treding@nvidia.com>

13 files changed, 898 insertions, 365 deletions

diff --git a/drivers/gpu/host1x/Makefile b/drivers/gpu/host1x/Makefile
index 3b037b6e0298..7b781920c58a 100644
--- a/drivers/gpu/host1x/Makefile
+++ b/drivers/gpu/host1x/Makefile
@@ -1,6 +1,7 @@
 ccflags-y = -Idrivers/gpu/host1x
 
 host1x-y = \
+        bus.o \
         syncpt.o \
         dev.o \
         intr.o \
@@ -17,4 +18,5 @@ host1x-$(CONFIG_DRM_TEGRA) += drm/drm.o drm/fb.o drm/dc.o
 host1x-$(CONFIG_DRM_TEGRA) += drm/output.o drm/rgb.o drm/hdmi.o
 host1x-$(CONFIG_DRM_TEGRA) += drm/gem.o
 host1x-$(CONFIG_DRM_TEGRA) += drm/gr2d.o
+host1x-$(CONFIG_DRM_TEGRA) += drm/bus.o
 obj-$(CONFIG_TEGRA_HOST1X) += host1x.o
diff --git a/drivers/gpu/host1x/bus.c b/drivers/gpu/host1x/bus.c
new file mode 100644
index 000000000000..509383f8be03
--- /dev/null
+++ b/drivers/gpu/host1x/bus.c
@@ -0,0 +1,550 @@
+/*
+ * Copyright (C) 2012 Avionic Design GmbH
+ * Copyright (C) 2012-2013, NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/host1x.h>
+#include <linux/of.h>
+#include <linux/slab.h>
+
+#include "dev.h"
+
+static DEFINE_MUTEX(clients_lock);
+static LIST_HEAD(clients);
+
+static DEFINE_MUTEX(drivers_lock);
+static LIST_HEAD(drivers);
+
+static DEFINE_MUTEX(devices_lock);
+static LIST_HEAD(devices);
+
+struct host1x_subdev {
+        struct host1x_client *client;
+        struct device_node *np;
+        struct list_head list;
+};
+
+/**
+ * host1x_subdev_add() - add a new subdevice with an associated device node
+ */
+static int host1x_subdev_add(struct host1x_device *device,
+                             struct device_node *np)
+{
+        struct host1x_subdev *subdev;
+
+        subdev = kzalloc(sizeof(*subdev), GFP_KERNEL);
+        if (!subdev)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(&subdev->list);
+        subdev->np = of_node_get(np);
+
+        mutex_lock(&device->subdevs_lock);
+        list_add_tail(&subdev->list, &device->subdevs);
+        mutex_unlock(&device->subdevs_lock);
+
+        return 0;
+}
+
+/**
+ * host1x_subdev_del() - remove subdevice
+ */
+static void host1x_subdev_del(struct host1x_subdev *subdev)
+{
+        list_del(&subdev->list);
+        of_node_put(subdev->np);
+        kfree(subdev);
+}
+
+/**
+ * host1x_device_parse_dt() - scan device tree and add matching subdevices
+ */
+static int host1x_device_parse_dt(struct host1x_device *device)
+{
+        struct device_node *np;
+        int err;
+
+        for_each_child_of_node(device->dev.parent->of_node, np) {
+                if (of_match_node(device->driver->subdevs, np) &&
+                    of_device_is_available(np)) {
+                        err = host1x_subdev_add(device, np);
+                        if (err < 0)
+                                return err;
+                }
+        }
+
+        return 0;
+}
+
+static void host1x_subdev_register(struct host1x_device *device,
+                                   struct host1x_subdev *subdev,
+                                   struct host1x_client *client)
+{
+        int err;
+
+        /*
+         * Move the subdevice to the list of active (registered) subdevices
+         * and associate it with a client. At the same time, associate the
+         * client with its parent device.
+         */
+        mutex_lock(&device->subdevs_lock);
+        mutex_lock(&device->clients_lock);
+        list_move_tail(&client->list, &device->clients);
+        list_move_tail(&subdev->list, &device->active);
+        client->parent = &device->dev;
+        subdev->client = client;
+        mutex_unlock(&device->clients_lock);
+        mutex_unlock(&device->subdevs_lock);
+
+        /*
+         * When all subdevices have been registered, the composite device is
+         * ready to be probed.
+         */
+        if (list_empty(&device->subdevs)) {
+                err = device->driver->probe(device);
+                if (err < 0)
+                        dev_err(&device->dev, "probe failed: %d\n", err);
+        }
+}
+
+static void __host1x_subdev_unregister(struct host1x_device *device,
+                                       struct host1x_subdev *subdev)
+{
+        struct host1x_client *client = subdev->client;
+        int err;
+
+        /*
+         * If all subdevices have been activated, we're about to remove the
+         * first active subdevice, so unload the driver first.
+         */
+        if (list_empty(&device->subdevs)) {
+                err = device->driver->remove(device);
+                if (err < 0)
+                        dev_err(&device->dev, "remove failed: %d\n", err);
+        }
+
+        /*
+         * Move the subdevice back to the list of idle subdevices and remove
+         * it from list of clients.
+         */
+        mutex_lock(&device->clients_lock);
+        subdev->client = NULL;
+        client->parent = NULL;
+        list_move_tail(&subdev->list, &device->subdevs);
+        /*
+         * XXX: Perhaps don't do this here, but rather explicitly remove it
+         * when the device is about to be deleted.
+         *
+         * This is somewhat complicated by the fact that this function is
+         * used to remove the subdevice when a client is unregistered but
+         * also when the composite device is about to be removed.
+         */
+        list_del_init(&client->list);
+        mutex_unlock(&device->clients_lock);
+}
+
+static void host1x_subdev_unregister(struct host1x_device *device,
+                                     struct host1x_subdev *subdev)