drivers/staging/media/imx/imx-media-of.c - arm/linux - Git at Google

 /*
  * Media driver for Freescale i.MX5/6 SOC
  *
  * Open Firmware parsing.
  *
  * Copyright (c) 2016 Mentor Graphics Inc.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  */
 #include <linux/of_platform.h>
 #include <media/v4l2-ctrls.h>
 #include <media/v4l2-device.h>
 #include <media/v4l2-fwnode.h>
 #include <media/v4l2-subdev.h>
 #include <media/videobuf2-dma-contig.h>
 #include <linux/of_graph.h>
 #include <video/imx-ipu-v3.h>
 #include "imx-media.h"

 static int of_add_pad_link(struct imx_media_dev *imxmd,
 			   struct imx_media_pad *pad,
 			   struct device_node *local_sd_node,
 			   struct device_node *remote_sd_node,
 			   int local_pad, int remote_pad)
 {
 	dev_dbg(imxmd->md.dev, "%s: adding %s:%d -> %s:%d\n", __func__,
 		local_sd_node->name, local_pad,
 		remote_sd_node->name, remote_pad);

 	return imx_media_add_pad_link(imxmd, pad, remote_sd_node, NULL,
 				      local_pad, remote_pad);
 }

 static void of_parse_sensor(struct imx_media_dev *imxmd,
 			    struct imx_media_subdev *sensor,
 			    struct device_node *sensor_np)
 {
 	struct device_node *endpoint;

 	endpoint = of_graph_get_next_endpoint(sensor_np, NULL);
 	if (endpoint) {
 		v4l2_fwnode_endpoint_parse(of_fwnode_handle(endpoint),
 					   &sensor->sensor_ep);
 		of_node_put(endpoint);
 	}
 }

 static int of_get_port_count(const struct device_node *np)
 {
 	struct device_node *ports, *child;
 	int num = 0;

 	/* check if this node has a ports subnode */
 	ports = of_get_child_by_name(np, "ports");
 	if (ports)
 		np = ports;

 	for_each_child_of_node(np, child)
 		if (of_node_cmp(child->name, "port") == 0)
 			num++;

 	of_node_put(ports);
 	return num;
 }

 /*
  * find the remote device node and remote port id (remote pad #)
  * given local endpoint node
  */
 static void of_get_remote_pad(struct device_node *epnode,
 			      struct device_node **remote_node,
 			      int *remote_pad)
 {
 	struct device_node *rp, *rpp;
 	struct device_node *remote;

 	rp = of_graph_get_remote_port(epnode);
 	rpp = of_graph_get_remote_port_parent(epnode);

 	if (of_device_is_compatible(rpp, "fsl,imx6q-ipu")) {
 		/* the remote is one of the CSI ports */
 		remote = rp;
 		*remote_pad = 0;
 		of_node_put(rpp);
 	} else {
 		remote = rpp;
 		if (of_property_read_u32(rp, "reg", remote_pad))
 			*remote_pad = 0;
 		of_node_put(rp);
 	}

 	if (!of_device_is_available(remote)) {
 		of_node_put(remote);
 		*remote_node = NULL;
 	} else {
 		*remote_node = remote;
 	}
 }

 static int
 of_parse_subdev(struct imx_media_dev *imxmd, struct device_node *sd_np,
 		bool is_csi_port, struct imx_media_subdev **subdev)
 {
 	struct imx_media_subdev *imxsd;
 	int i, num_pads, ret;

 	if (!of_device_is_available(sd_np)) {
 		dev_dbg(imxmd->md.dev, "%s: %s not enabled\n", __func__,
 			sd_np->name);
 		*subdev = NULL;
 		/* unavailable is not an error */
 		return 0;
 	}

 	/* register this subdev with async notifier */
 	imxsd = imx_media_add_async_subdev(imxmd, sd_np, NULL);
 	ret = PTR_ERR_OR_ZERO(imxsd);
 	if (ret) {
 		if (ret == -EEXIST) {
 			/* already added, everything is fine */
 			*subdev = NULL;
 			return 0;
 		}

 		/* other error, can't continue */
 		return ret;
 	}
 	*subdev = imxsd;

 	if (is_csi_port) {
 		/*
 		 * the ipu-csi has one sink port and two source ports.
 		 * The source ports are not represented in the device tree,
 		 * but are described by the internal pads and links later.
 		 */
 		num_pads = CSI_NUM_PADS;
 		imxsd->num_sink_pads = CSI_NUM_SINK_PADS;
 	} else if (of_device_is_compatible(sd_np, "fsl,imx6-mipi-csi2")) {
 		num_pads = of_get_port_count(sd_np);
 		/* the mipi csi2 receiver has only one sink port */
 		imxsd->num_sink_pads = 1;
 	} else if (of_device_is_compatible(sd_np, "video-mux")) {
 		num_pads = of_get_port_count(sd_np);
 		/* for the video mux, all but the last port are sinks */
 		imxsd->num_sink_pads = num_pads - 1;
 	} else {
 		num_pads = of_get_port_count(sd_np);
 		if (num_pads != 1) {
 			/* confused, but no reason to give up here */
 			dev_warn(imxmd->md.dev,
 				 "%s: unknown device %s with %d ports\n",
 				 __func__, sd_np->name, num_pads);
 			return 0;
 		}

 		/*
 		 * we got to this node from this single source port,
 		 * there are no sink pads.
 		 */
 		imxsd->num_sink_pads = 0;
 	}

 	if (imxsd->num_sink_pads >= num_pads)
 		return -EINVAL;

 	imxsd->num_src_pads = num_pads - imxsd->num_sink_pads;

 	dev_dbg(imxmd->md.dev, "%s: %s has %d pads (%d sink, %d src)\n",
 		__func__, sd_np->name, num_pads,
 		imxsd->num_sink_pads, imxsd->num_src_pads);

 	/*
 	 * With no sink, this subdev node is the original source
 	 * of video, parse it's media bus for use by the pipeline.
 	 */
 	if (imxsd->num_sink_pads == 0)
 		of_parse_sensor(imxmd, imxsd, sd_np);

 	for (i = 0; i < num_pads; i++) {
 		struct device_node *epnode = NULL, *port, *remote_np;
 		struct imx_media_subdev *remote_imxsd;
 		struct imx_media_pad *pad;
 		int remote_pad;

 		/* init this pad */
 		pad = &imxsd->pad[i];
 		pad->pad.flags = (i < imxsd->num_sink_pads) ?
 			MEDIA_PAD_FL_SINK : MEDIA_PAD_FL_SOURCE;

 		if (is_csi_port)
 			port = (i < imxsd->num_sink_pads) ? sd_np : NULL;
 		else
 			port = of_graph_get_port_by_id(sd_np, i);
 		if (!port)
 			continue;

 		for_each_child_of_node(port, epnode) {
 			of_get_remote_pad(epnode, &remote_np, &remote_pad);
 			if (!remote_np)
 				continue;

 			ret = of_add_pad_link(imxmd, pad, sd_np, remote_np,
 					      i, remote_pad);
 			if (ret)
 				break;

 			if (i < imxsd->num_sink_pads) {
 				/* follow sink endpoints upstream */
 				ret = of_parse_subdev(imxmd, remote_np,
 						      false, &remote_imxsd);
 				if (ret)
 					break;
 			}

 			of_node_put(remote_np);
 		}

 		if (port != sd_np)
 			of_node_put(port);
 		if (ret) {
 			of_node_put(remote_np);
 			of_node_put(epnode);
 			break;
 		}
 	}

 	return ret;
 }

 int imx_media_of_parse(struct imx_media_dev *imxmd,
 		       struct imx_media_subdev *(*csi)[4],
 		       struct device_node *np)
 {
 	struct imx_media_subdev *lcsi;
 	struct device_node *csi_np;
 	u32 ipu_id, csi_id;
 	int i, ret;

 	for (i = 0; ; i++) {
 		csi_np = of_parse_phandle(np, "ports", i);
 		if (!csi_np)
 			break;

 		ret = of_parse_subdev(imxmd, csi_np, true, &lcsi);
 		if (ret)
 			goto err_put;

 		ret = of_property_read_u32(csi_np, "reg", &csi_id);
 		if (ret) {
 			dev_err(imxmd->md.dev,
 				"%s: csi port missing reg property!\n",
 				__func__);
 			goto err_put;
 		}

 		ipu_id = of_alias_get_id(csi_np->parent, "ipu");
 		of_node_put(csi_np);

 		if (ipu_id > 1 || csi_id > 1) {
 			dev_err(imxmd->md.dev,
 				"%s: invalid ipu/csi id (%u/%u)\n",
 				__func__, ipu_id, csi_id);
 			return -EINVAL;
 		}

 		(*csi)[ipu_id * 2 + csi_id] = lcsi;
 	}

 	return 0;
 err_put:
 	of_node_put(csi_np);
 	return ret;
 }
	/*
	* Media driver for Freescale i.MX5/6 SOC
	*
	* Open Firmware parsing.
	*
	* Copyright (c) 2016 Mentor Graphics Inc.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*/
	#include <linux/of_platform.h>
	#include <media/v4l2-ctrls.h>
	#include <media/v4l2-device.h>
	#include <media/v4l2-fwnode.h>
	#include <media/v4l2-subdev.h>
	#include <media/videobuf2-dma-contig.h>
	#include <linux/of_graph.h>
	#include <video/imx-ipu-v3.h>
	#include "imx-media.h"

	static int of_add_pad_link(struct imx_media_dev *imxmd,
	struct imx_media_pad *pad,
	struct device_node *local_sd_node,
	struct device_node *remote_sd_node,
	int local_pad, int remote_pad)
	{
	dev_dbg(imxmd->md.dev, "%s: adding %s:%d -> %s:%d\n", __func__,
	local_sd_node->name, local_pad,
	remote_sd_node->name, remote_pad);

	return imx_media_add_pad_link(imxmd, pad, remote_sd_node, NULL,
	local_pad, remote_pad);
	}

	static void of_parse_sensor(struct imx_media_dev *imxmd,
	struct imx_media_subdev *sensor,
	struct device_node *sensor_np)
	{
	struct device_node *endpoint;

	endpoint = of_graph_get_next_endpoint(sensor_np, NULL);
	if (endpoint) {
	v4l2_fwnode_endpoint_parse(of_fwnode_handle(endpoint),
	&sensor->sensor_ep);
	of_node_put(endpoint);
	}
	}

	static int of_get_port_count(const struct device_node *np)
	{
	struct device_node ports, child;
	int num = 0;

	/* check if this node has a ports subnode */
	ports = of_get_child_by_name(np, "ports");
	if (ports)
	np = ports;

	for_each_child_of_node(np, child)
	if (of_node_cmp(child->name, "port") == 0)
	num++;

	of_node_put(ports);
	return num;
	}

	/*
	* find the remote device node and remote port id (remote pad #)
	* given local endpoint node
	*/
	static void of_get_remote_pad(struct device_node *epnode,
	struct device_node **remote_node,
	int *remote_pad)
	{
	struct device_node rp, rpp;
	struct device_node *remote;

	rp = of_graph_get_remote_port(epnode);
	rpp = of_graph_get_remote_port_parent(epnode);

	if (of_device_is_compatible(rpp, "fsl,imx6q-ipu")) {
	/* the remote is one of the CSI ports */
	remote = rp;
	*remote_pad = 0;
	of_node_put(rpp);
	} else {
	remote = rpp;
	if (of_property_read_u32(rp, "reg", remote_pad))
	*remote_pad = 0;
	of_node_put(rp);
	}

	if (!of_device_is_available(remote)) {
	of_node_put(remote);
	*remote_node = NULL;
	} else {
	*remote_node = remote;
	}
	}

	static int
	of_parse_subdev(struct imx_media_dev imxmd, struct device_node sd_np,
	bool is_csi_port, struct imx_media_subdev **subdev)
	{
	struct imx_media_subdev *imxsd;
	int i, num_pads, ret;

	if (!of_device_is_available(sd_np)) {
	dev_dbg(imxmd->md.dev, "%s: %s not enabled\n", __func__,
	sd_np->name);
	*subdev = NULL;
	/* unavailable is not an error */
	return 0;
	}

	/* register this subdev with async notifier */
	imxsd = imx_media_add_async_subdev(imxmd, sd_np, NULL);
	ret = PTR_ERR_OR_ZERO(imxsd);
	if (ret) {
	if (ret == -EEXIST) {
	/* already added, everything is fine */
	*subdev = NULL;
	return 0;
	}

	/* other error, can't continue */
	return ret;
	}
	*subdev = imxsd;

	if (is_csi_port) {
	/*
	* the ipu-csi has one sink port and two source ports.
	* The source ports are not represented in the device tree,
	* but are described by the internal pads and links later.
	*/
	num_pads = CSI_NUM_PADS;
	imxsd->num_sink_pads = CSI_NUM_SINK_PADS;
	} else if (of_device_is_compatible(sd_np, "fsl,imx6-mipi-csi2")) {
	num_pads = of_get_port_count(sd_np);
	/* the mipi csi2 receiver has only one sink port */
	imxsd->num_sink_pads = 1;
	} else if (of_device_is_compatible(sd_np, "video-mux")) {
	num_pads = of_get_port_count(sd_np);
	/* for the video mux, all but the last port are sinks */
	imxsd->num_sink_pads = num_pads - 1;
	} else {
	num_pads = of_get_port_count(sd_np);
	if (num_pads != 1) {
	/* confused, but no reason to give up here */
	dev_warn(imxmd->md.dev,
	"%s: unknown device %s with %d ports\n",
	__func__, sd_np->name, num_pads);
	return 0;
	}

	/*
	* we got to this node from this single source port,
	* there are no sink pads.
	*/
	imxsd->num_sink_pads = 0;
	}

	if (imxsd->num_sink_pads >= num_pads)
	return -EINVAL;

	imxsd->num_src_pads = num_pads - imxsd->num_sink_pads;

	dev_dbg(imxmd->md.dev, "%s: %s has %d pads (%d sink, %d src)\n",
	__func__, sd_np->name, num_pads,
	imxsd->num_sink_pads, imxsd->num_src_pads);

	/*
	* With no sink, this subdev node is the original source
	* of video, parse it's media bus for use by the pipeline.
	*/
	if (imxsd->num_sink_pads == 0)
	of_parse_sensor(imxmd, imxsd, sd_np);

	for (i = 0; i < num_pads; i++) {
	struct device_node epnode = NULL, port, *remote_np;
	struct imx_media_subdev *remote_imxsd;
	struct imx_media_pad *pad;
	int remote_pad;

	/* init this pad */
	pad = &imxsd->pad[i];
	pad->pad.flags = (i < imxsd->num_sink_pads) ?
	MEDIA_PAD_FL_SINK : MEDIA_PAD_FL_SOURCE;

	if (is_csi_port)
	port = (i < imxsd->num_sink_pads) ? sd_np : NULL;
	else
	port = of_graph_get_port_by_id(sd_np, i);
	if (!port)
	continue;

	for_each_child_of_node(port, epnode) {
	of_get_remote_pad(epnode, &remote_np, &remote_pad);
	if (!remote_np)
	continue;

	ret = of_add_pad_link(imxmd, pad, sd_np, remote_np,
	i, remote_pad);
	if (ret)
	break;

	if (i < imxsd->num_sink_pads) {
	/* follow sink endpoints upstream */
	ret = of_parse_subdev(imxmd, remote_np,
	false, &remote_imxsd);
	if (ret)
	break;
	}

	of_node_put(remote_np);
	}

	if (port != sd_np)
	of_node_put(port);
	if (ret) {
	of_node_put(remote_np);
	of_node_put(epnode);
	break;
	}
	}

	return ret;
	}

	int imx_media_of_parse(struct imx_media_dev *imxmd,
	struct imx_media_subdev (csi)[4],
	struct device_node *np)
	{
	struct imx_media_subdev *lcsi;
	struct device_node *csi_np;
	u32 ipu_id, csi_id;
	int i, ret;

	for (i = 0; ; i++) {
	csi_np = of_parse_phandle(np, "ports", i);
	if (!csi_np)
	break;

	ret = of_parse_subdev(imxmd, csi_np, true, &lcsi);
	if (ret)
	goto err_put;

	ret = of_property_read_u32(csi_np, "reg", &csi_id);
	if (ret) {
	dev_err(imxmd->md.dev,
	"%s: csi port missing reg property!\n",
	__func__);
	goto err_put;
	}

	ipu_id = of_alias_get_id(csi_np->parent, "ipu");
	of_node_put(csi_np);

	if (ipu_id > 1 \|\| csi_id > 1) {
	dev_err(imxmd->md.dev,
	"%s: invalid ipu/csi id (%u/%u)\n",
	__func__, ipu_id, csi_id);
	return -EINVAL;
	}

	(csi)[ipu_id 2 + csi_id] = lcsi;
	}

	return 0;
	err_put:
	of_node_put(csi_np);
	return ret;
	}