[media] omap3isp: Add support for the Device Tree

Add the ISP device to omap3 DT include file and add support to the driver to
use it.

Also obtain information on the external entities and the ISP configuration
related to them through the Device Tree in addition to the platform data.

Signed-off-by: Sakari Ailus <sakari.ailus@iki.fi>
Acked-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@osg.samsung.com>

3 files changed, 224 insertions, 12 deletions

diff --git a/drivers/media/platform/omap3isp/isp.c b/drivers/media/platform/omap3isp/isp.c
index 992e74c3471d..9ef7e035aa6c 100644
--- a/drivers/media/platform/omap3isp/isp.c
+++ b/drivers/media/platform/omap3isp/isp.c
@@ -64,6 +64,7 @@
 
 #include <media/v4l2-common.h>
 #include <media/v4l2-device.h>
+#include <media/v4l2-of.h>
 
 #include "isp.h"
 #include "ispreg.h"
@@ -1991,6 +1992,13 @@ static int isp_register_entities(struct isp_device *isp)
         if (ret < 0)
                 goto done;
 
+        /*
+         * Device Tree --- the external sub-devices will be registered
+         * later. The same goes for the sub-device node registration.
+         */
+        if (isp->dev->of_node)
+                return 0;
+
         /* Register external entities */
         for (isp_subdev = pdata ? pdata->subdevs : NULL;
              isp_subdev && isp_subdev->board_info; isp_subdev++) {
@@ -2016,8 +2024,10 @@ static int isp_register_entities(struct isp_device *isp)
         ret = v4l2_device_register_subdev_nodes(&isp->v4l2_dev);
 
 done:
-        if (ret < 0)
+        if (ret < 0) {
                 isp_unregister_entities(isp);
+                v4l2_async_notifier_unregister(&isp->notifier);
+        }
 
         return ret;
 }
@@ -2232,6 +2242,7 @@ static int isp_remove(struct platform_device *pdev)
 {
         struct isp_device *isp = platform_get_drvdata(pdev);
 
+        v4l2_async_notifier_unregister(&isp->notifier);
         isp_unregister_entities(isp);
         isp_cleanup_modules(isp);
         isp_xclk_cleanup(isp);
@@ -2243,6 +2254,156 @@ static int isp_remove(struct platform_device *pdev)
         return 0;
 }
 
+enum isp_of_phy {
+        ISP_OF_PHY_PARALLEL = 0,
+        ISP_OF_PHY_CSIPHY1,
+        ISP_OF_PHY_CSIPHY2,
+};
+
+static int isp_of_parse_node(struct device *dev, struct device_node *node,
+                             struct isp_async_subdev *isd)
+{
+        struct isp_bus_cfg *buscfg = &isd->bus;
+        struct v4l2_of_endpoint vep;
+        unsigned int i;
+
+        v4l2_of_parse_endpoint(node, &vep);
+
+        dev_dbg(dev, "parsing endpoint %s, interface %u\n", node->full_name,
+                vep.base.port);
+
+        switch (vep.base.port) {
+        case ISP_OF_PHY_PARALLEL:
+                buscfg->interface = ISP_INTERFACE_PARALLEL;
+                buscfg->bus.parallel.data_lane_shift =
+                        vep.bus.parallel.data_shift;
+                buscfg->bus.parallel.clk_pol =
+                        !!(vep.bus.parallel.flags
+                           & V4L2_MBUS_PCLK_SAMPLE_FALLING);
+                buscfg->bus.parallel.hs_pol =
+                        !!(vep.bus.parallel.flags & V4L2_MBUS_VSYNC_ACTIVE_LOW);
+                buscfg->bus.parallel.vs_pol =
+                        !!(vep.bus.parallel.flags & V4L2_MBUS_HSYNC_ACTIVE_LOW);
+                buscfg->bus.parallel.fld_pol =
+                        !!(vep.bus.parallel.flags & V4L2_MBUS_FIELD_EVEN_LOW);
+                buscfg->bus.parallel.data_pol =
+                        !!(vep.bus.parallel.flags & V4L2_MBUS_DATA_ACTIVE_LOW);
+                break;
+
+        case ISP_OF_PHY_CSIPHY1:
+        case ISP_OF_PHY_CSIPHY2:
+                /* FIXME: always assume CSI-2 for now. */
+                switch (vep.base.port) {
+                case ISP_OF_PHY_CSIPHY1:
+                        buscfg->interface = ISP_INTERFACE_CSI2C_PHY1;
+                        break;
+                case ISP_OF_PHY_CSIPHY2:
+                        buscfg->interface = ISP_INTERFACE_CSI2A_PHY2;
+                        break;
+                }
+                buscfg->bus.csi2.lanecfg.clk.pos = vep.bus.mipi_csi2.clock_lane;
+                buscfg->bus.csi2.lanecfg.clk.pol =
+                        vep.bus.mipi_csi2.lane_polarities[0];
+                dev_dbg(dev, "clock lane polarity %u, pos %u\n",
+                        buscfg->bus.csi2.lanecfg.clk.pol,
+                        buscfg->bus.csi2.lanecfg.clk.pos);
+
+                for (i = 0; i < ISP_CSIPHY2_NUM_DATA_LANES; i++) {
+                        buscfg->bus.csi2.lanecfg.data[i].pos =
+                                vep.bus.mipi_csi2.data_lanes[i];
+                        buscfg->bus.csi2.lanecfg.data[i].pol =
+                                vep.bus.mipi_csi2.lane_polarities[i + 1];
+                        dev_dbg(dev, "data lane %u polarity %u, pos %u\n", i,
+                                buscfg->bus.csi2.lanecfg.data[i].pol,
+                                buscfg->bus.csi2.lanecfg.data[i].pos);
+                }
+
+                /*
+                 * FIXME: now we assume the CRC is always there.
+                 * Implement a way to obtain this information from the
+                 * sensor. Frame descriptors, perhaps?
+                 */
+                buscfg->bus.csi2.crc = 1;
+                break;
+
+        default:
+                dev_warn(dev, "%s: invalid interface %u\n", node->full_name,
+                         vep.base.port);
+                break;
+        }
+
+        return 0;
+}
+
+static int isp_of_parse_nodes(struct device *dev,
+                              struct v4l2_async_notifier *notifier)
+{
+        struct device_node *node = NULL;
+
+        notifier->subdevs = devm_kcalloc(
+                dev, ISP_MAX_SUBDEVS, sizeof(*notifier->subdevs), GFP_KERNEL);
+        if (!notifier->subdevs)
+                return -ENOMEM;
+
+        while (notifier->num_subdevs < ISP_MAX_SUBDEVS &&
+               (node = of_graph_get_next_endpoint(dev->of_node, node))) {
+                struct isp_async_subdev *isd;
+
+                isd = devm_kzalloc(dev, sizeof(*isd), GFP_KERNEL);
+                if (!isd) {
+                        of_node_put(node);
+                        return -ENOMEM;
+                }
+
+                notifier->subdevs[notifier->num_subdevs] = &isd->asd;
+
+                if (isp_of_parse_node(dev, node, isd)) {
+                        of_node_put(node);
+                        return -EINVAL;
+                }
+
+                isd->asd.match.of.node = of_graph_get_remote_port_parent(node);
+                of_node_put(node);
+                if (!isd->asd.match.of.node) {
+                        dev_warn(dev, "bad remote port parent\n");
+                        return -EINVAL;
+                }
+
+                isd->asd.match_type = V4L2_ASYNC_MATCH_OF;
+                notifier->num_subdevs++;
+        }
+
+        return notifier->num_subdevs;
+}
+
+static int isp_subdev_notifier_bound(struct v4l2_async_notifier *async,