[deliverable/linux.git] / drivers / media / v4l2-core / v4l2-of.c

/*
 * V4L2 OF binding parsing library
 *
 * Copyright (C) 2012 - 2013 Samsung Electronics Co., Ltd.
 * Author: Sylwester Nawrocki <s.nawrocki@samsung.com>
 *
 * Copyright (C) 2012 Renesas Electronics Corp.
 * Author: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/types.h>

#include <media/v4l2-of.h>

static int v4l2_of_parse_csi_bus(const struct device_node *node,
				 struct v4l2_of_endpoint *endpoint)
{
	struct v4l2_of_bus_mipi_csi2 *bus = &endpoint->bus.mipi_csi2;
	struct property *prop;
	bool have_clk_lane = false;
	unsigned int flags = 0;
	u32 v;

	prop = of_find_property(node, "data-lanes", NULL);
	if (prop) {
		const __be32 *lane = NULL;
		unsigned int i;

		for (i = 0; i < ARRAY_SIZE(bus->data_lanes); i++) {
			lane = of_prop_next_u32(prop, lane, &v);
			if (!lane)
				break;
			bus->data_lanes[i] = v;
		}
		bus->num_data_lanes = i;
	}

	prop = of_find_property(node, "lane-polarities", NULL);
	if (prop) {
		const __be32 *polarity = NULL;
		unsigned int i;

		for (i = 0; i < ARRAY_SIZE(bus->lane_polarities); i++) {
			polarity = of_prop_next_u32(prop, polarity, &v);
			if (!polarity)
				break;
			bus->lane_polarities[i] = v;
		}

		if (i < 1 + bus->num_data_lanes /* clock + data */) {
			pr_warn("%s: too few lane-polarities entries (need %u, got %u)\n",
				node->full_name, 1 + bus->num_data_lanes, i);
			return -EINVAL;
		}
	}

	if (!of_property_read_u32(node, "clock-lanes", &v)) {
		bus->clock_lane = v;
		have_clk_lane = true;
	}

	if (of_get_property(node, "clock-noncontinuous", &v))
		flags |= V4L2_MBUS_CSI2_NONCONTINUOUS_CLOCK;
	else if (have_clk_lane || bus->num_data_lanes > 0)
		flags |= V4L2_MBUS_CSI2_CONTINUOUS_CLOCK;

	bus->flags = flags;
	endpoint->bus_type = V4L2_MBUS_CSI2;

	return 0;
}

static void v4l2_of_parse_parallel_bus(const struct device_node *node,
				       struct v4l2_of_endpoint *endpoint)
{
	struct v4l2_of_bus_parallel *bus = &endpoint->bus.parallel;
	unsigned int flags = 0;
	u32 v;

	if (!of_property_read_u32(node, "hsync-active", &v))
		flags |= v ? V4L2_MBUS_HSYNC_ACTIVE_HIGH :
			V4L2_MBUS_HSYNC_ACTIVE_LOW;

	if (!of_property_read_u32(node, "vsync-active", &v))
		flags |= v ? V4L2_MBUS_VSYNC_ACTIVE_HIGH :
			V4L2_MBUS_VSYNC_ACTIVE_LOW;

	if (!of_property_read_u32(node, "field-even-active", &v))
		flags |= v ? V4L2_MBUS_FIELD_EVEN_HIGH :
			V4L2_MBUS_FIELD_EVEN_LOW;
	if (flags)
		endpoint->bus_type = V4L2_MBUS_PARALLEL;
	else
		endpoint->bus_type = V4L2_MBUS_BT656;

	if (!of_property_read_u32(node, "pclk-sample", &v))
		flags |= v ? V4L2_MBUS_PCLK_SAMPLE_RISING :
			V4L2_MBUS_PCLK_SAMPLE_FALLING;

	if (!of_property_read_u32(node, "data-active", &v))
		flags |= v ? V4L2_MBUS_DATA_ACTIVE_HIGH :
			V4L2_MBUS_DATA_ACTIVE_LOW;

	if (of_get_property(node, "slave-mode", &v))
		flags |= V4L2_MBUS_SLAVE;
	else
		flags |= V4L2_MBUS_MASTER;

	if (!of_property_read_u32(node, "bus-width", &v))
		bus->bus_width = v;

	if (!of_property_read_u32(node, "data-shift", &v))
		bus->data_shift = v;

	if (!of_property_read_u32(node, "sync-on-green-active", &v))
		flags |= v ? V4L2_MBUS_VIDEO_SOG_ACTIVE_HIGH :
			V4L2_MBUS_VIDEO_SOG_ACTIVE_LOW;

	bus->flags = flags;

}

/**
 * v4l2_of_parse_endpoint() - parse all endpoint node properties
 * @node: pointer to endpoint device_node
 * @endpoint: pointer to the V4L2 OF endpoint data structure
 *
 * All properties are optional. If none are found, we don't set any flags.
 * This means the port has a static configuration and no properties have
 * to be specified explicitly.
 * If any properties that identify the bus as parallel are found and
 * slave-mode isn't set, we set V4L2_MBUS_MASTER. Similarly, if we recognise
 * the bus as serial CSI-2 and clock-noncontinuous isn't set, we set the
 * V4L2_MBUS_CSI2_CONTINUOUS_CLOCK flag.
 * The caller should hold a reference to @node.
 *
 * NOTE: This function does not parse properties the size of which is
 * variable without a low fixed limit. Please use
 * v4l2_of_alloc_parse_endpoint() in new drivers instead.
 *
 * Return: 0.
 */
int v4l2_of_parse_endpoint(const struct device_node *node,
			   struct v4l2_of_endpoint *endpoint)
{
	int rval;

	of_graph_parse_endpoint(node, &endpoint->base);
	/* Zero fields from bus_type to until the end */
	memset(&endpoint->bus_type, 0, sizeof(*endpoint) -
	       offsetof(typeof(*endpoint), bus_type));

	rval = v4l2_of_parse_csi_bus(node, endpoint);
	if (rval)
		return rval;
	/*
	 * Parse the parallel video bus properties only if none
	 * of the MIPI CSI-2 specific properties were found.
	 */
	if (endpoint->bus.mipi_csi2.flags == 0)
		v4l2_of_parse_parallel_bus(node, endpoint);

	return 0;
}
EXPORT_SYMBOL(v4l2_of_parse_endpoint);

/*
 * v4l2_of_free_endpoint() - free the endpoint acquired by
 * v4l2_of_alloc_parse_endpoint()
 * @endpoint - the endpoint the resources of which are to be released
 *
 * It is safe to call this function with NULL argument or on an
 * endpoint the parsing of which failed.
 */
void v4l2_of_free_endpoint(struct v4l2_of_endpoint *endpoint)
{
	if (IS_ERR_OR_NULL(endpoint))
		return;

	kfree(endpoint->link_frequencies);
	kfree(endpoint);
}
EXPORT_SYMBOL(v4l2_of_free_endpoint);

/**
 * v4l2_of_alloc_parse_endpoint() - parse all endpoint node properties
 * @node: pointer to endpoint device_node
 *
 * All properties are optional. If none are found, we don't set any flags.
 * This means the port has a static configuration and no properties have
 * to be specified explicitly.
 * If any properties that identify the bus as parallel are found and
 * slave-mode isn't set, we set V4L2_MBUS_MASTER. Similarly, if we recognise
 * the bus as serial CSI-2 and clock-noncontinuous isn't set, we set the
 * V4L2_MBUS_CSI2_CONTINUOUS_CLOCK flag.
 * The caller should hold a reference to @node.
 *
 * v4l2_of_alloc_parse_endpoint() has two important differences to
 * v4l2_of_parse_endpoint():
 *
 * 1. It also parses variable size data and
 *
 * 2. The memory it has allocated to store the variable size data must
 *    be freed using v4l2_of_free_endpoint() when no longer needed.
 *
 * Return: Pointer to v4l2_of_endpoint if successful, on error a
 * negative error code.
 */
struct v4l2_of_endpoint *v4l2_of_alloc_parse_endpoint(
	const struct device_node *node)
{
	struct v4l2_of_endpoint *endpoint;
	int len;
	int rval;

	endpoint = kzalloc(sizeof(*endpoint), GFP_KERNEL);
	if (!endpoint)
		return ERR_PTR(-ENOMEM);

	rval = v4l2_of_parse_endpoint(node, endpoint);
	if (rval < 0)
		goto out_err;

	if (of_get_property(node, "link-frequencies", &len)) {
		endpoint->link_frequencies = kmalloc(len, GFP_KERNEL);
		if (!endpoint->link_frequencies) {
			rval = -ENOMEM;
			goto out_err;
		}

		endpoint->nr_of_link_frequencies =
			len / sizeof(*endpoint->link_frequencies);

		rval = of_property_read_u64_array(
			node, "link-frequencies", endpoint->link_frequencies,
			endpoint->nr_of_link_frequencies);
		if (rval < 0)
			goto out_err;
	}

	return endpoint;

out_err:
	v4l2_of_free_endpoint(endpoint);
	return ERR_PTR(rval);
}
EXPORT_SYMBOL(v4l2_of_alloc_parse_endpoint);

/**
 * v4l2_of_parse_link() - parse a link between two endpoints
 * @node: pointer to the endpoint at the local end of the link
 * @link: pointer to the V4L2 OF link data structure
 *
 * Fill the link structure with the local and remote nodes and port numbers.
 * The local_node and remote_node fields are set to point to the local and
 * remote port's parent nodes respectively (the port parent node being the
 * parent node of the port node if that node isn't a 'ports' node, or the
 * grand-parent node of the port node otherwise).
 *
 * A reference is taken to both the local and remote nodes, the caller must use
 * v4l2_of_put_link() to drop the references when done with the link.
 *
 * Return: 0 on success, or -ENOLINK if the remote endpoint can't be found.
 */
int v4l2_of_parse_link(const struct device_node *node,
		       struct v4l2_of_link *link)
{
	struct device_node *np;

	memset(link, 0, sizeof(*link));

	np = of_get_parent(node);
	of_property_read_u32(np, "reg", &link->local_port);
	np = of_get_next_parent(np);
	if (of_node_cmp(np->name, "ports") == 0)
		np = of_get_next_parent(np);
	link->local_node = np;

	np = of_parse_phandle(node, "remote-endpoint", 0);
	if (!np) {
		of_node_put(link->local_node);
		return -ENOLINK;
	}

	np = of_get_parent(np);
	of_property_read_u32(np, "reg", &link->remote_port);
	np = of_get_next_parent(np);
	if (of_node_cmp(np->name, "ports") == 0)
		np = of_get_next_parent(np);
	link->remote_node = np;

	return 0;
}
EXPORT_SYMBOL(v4l2_of_parse_link);

/**
 * v4l2_of_put_link() - drop references to nodes in a link
 * @link: pointer to the V4L2 OF link data structure
 *
 * Drop references to the local and remote nodes in the link. This function must
 * be called on every link parsed with v4l2_of_parse_link().
 */
void v4l2_of_put_link(struct v4l2_of_link *link)
{
	of_node_put(link->local_node);
	of_node_put(link->remote_node);
}
EXPORT_SYMBOL(v4l2_of_put_link);
Commit	Line	Data
99fd133f GL	1	/*
	2	* V4L2 OF binding parsing library
	3	*
	4	* Copyright (C) 2012 - 2013 Samsung Electronics Co., Ltd.
c6e8d96d	5	* Author: Sylwester Nawrocki <s.nawrocki@samsung.com>
99fd133f GL	6	*
	7	* Copyright (C) 2012 Renesas Electronics Corp.
	8	* Author: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of version 2 of the GNU General Public License as
	12	* published by the Free Software Foundation.
	13	*/
	14	#include <linux/kernel.h>
	15	#include <linux/module.h>
	16	#include <linux/of.h>
698da18e	17	#include <linux/slab.h>
99fd133f GL	18	#include <linux/string.h>
	19	#include <linux/types.h>
	20
	21	#include <media/v4l2-of.h>
	22
b6eec1c4 SA	23	static int v4l2_of_parse_csi_bus(const struct device_node *node,
b6eec1c4 SA	24	struct v4l2_of_endpoint *endpoint)
99fd133f GL	25	{
99fd133f GL	26	struct v4l2_of_bus_mipi_csi2 *bus = &endpoint->bus.mipi_csi2;
99fd133f GL	27	struct property *prop;
	28	bool have_clk_lane = false;
	29	unsigned int flags = 0;
	30	u32 v;
	31
	32	prop = of_find_property(node, "data-lanes", NULL);
	33	if (prop) {
	34	const __be32 *lane = NULL;
b6eec1c4	35	unsigned int i;
99fd133f	36
b6eec1c4 SA	37	for (i = 0; i < ARRAY_SIZE(bus->data_lanes); i++) {
b6eec1c4 SA	38	lane = of_prop_next_u32(prop, lane, &v);
99fd133f GL	39	if (!lane)
99fd133f GL	40	break;
b6eec1c4	41	bus->data_lanes[i] = v;
99fd133f GL	42	}
99fd133f GL	43	bus->num_data_lanes = i;
b6eec1c4 SA	44	}
	45
	46	prop = of_find_property(node, "lane-polarities", NULL);
	47	if (prop) {
	48	const __be32 *polarity = NULL;
	49	unsigned int i;
	50
	51	for (i = 0; i < ARRAY_SIZE(bus->lane_polarities); i++) {
	52	polarity = of_prop_next_u32(prop, polarity, &v);
	53	if (!polarity)
	54	break;
	55	bus->lane_polarities[i] = v;
	56	}
	57
	58	if (i < 1 + bus->num_data_lanes /* clock + data */) {
	59	pr_warn("%s: too few lane-polarities entries (need %u, got %u)\n",
	60	node->full_name, 1 + bus->num_data_lanes, i);
	61	return -EINVAL;
	62	}
99fd133f GL	63	}
	64
	65	if (!of_property_read_u32(node, "clock-lanes", &v)) {
	66	bus->clock_lane = v;
	67	have_clk_lane = true;
	68	}
	69
	70	if (of_get_property(node, "clock-noncontinuous", &v))
	71	flags \|= V4L2_MBUS_CSI2_NONCONTINUOUS_CLOCK;
	72	else if (have_clk_lane \|\| bus->num_data_lanes > 0)
	73	flags \|= V4L2_MBUS_CSI2_CONTINUOUS_CLOCK;
	74
	75	bus->flags = flags;
	76	endpoint->bus_type = V4L2_MBUS_CSI2;
b6eec1c4 SA	77
b6eec1c4 SA	78	return 0;
99fd133f GL	79	}
	80
	81	static void v4l2_of_parse_parallel_bus(const struct device_node *node,
	82	struct v4l2_of_endpoint *endpoint)
	83	{
	84	struct v4l2_of_bus_parallel *bus = &endpoint->bus.parallel;
	85	unsigned int flags = 0;
	86	u32 v;
	87
	88	if (!of_property_read_u32(node, "hsync-active", &v))
	89	flags \|= v ? V4L2_MBUS_HSYNC_ACTIVE_HIGH :
	90	V4L2_MBUS_HSYNC_ACTIVE_LOW;
	91
	92	if (!of_property_read_u32(node, "vsync-active", &v))
	93	flags \|= v ? V4L2_MBUS_VSYNC_ACTIVE_HIGH :
	94	V4L2_MBUS_VSYNC_ACTIVE_LOW;
	95
99fd133f GL	96	if (!of_property_read_u32(node, "field-even-active", &v))
	97	flags \|= v ? V4L2_MBUS_FIELD_EVEN_HIGH :
	98	V4L2_MBUS_FIELD_EVEN_LOW;
	99	if (flags)
	100	endpoint->bus_type = V4L2_MBUS_PARALLEL;
	101	else
	102	endpoint->bus_type = V4L2_MBUS_BT656;
	103
7a60743f ND	104	if (!of_property_read_u32(node, "pclk-sample", &v))
	105	flags \|= v ? V4L2_MBUS_PCLK_SAMPLE_RISING :
	106	V4L2_MBUS_PCLK_SAMPLE_FALLING;
	107
99fd133f GL	108	if (!of_property_read_u32(node, "data-active", &v))
	109	flags \|= v ? V4L2_MBUS_DATA_ACTIVE_HIGH :
	110	V4L2_MBUS_DATA_ACTIVE_LOW;
	111
	112	if (of_get_property(node, "slave-mode", &v))
	113	flags \|= V4L2_MBUS_SLAVE;
	114	else
	115	flags \|= V4L2_MBUS_MASTER;
	116
	117	if (!of_property_read_u32(node, "bus-width", &v))
	118	bus->bus_width = v;
	119
	120	if (!of_property_read_u32(node, "data-shift", &v))
	121	bus->data_shift = v;
	122
d1d70aa6 LP	123	if (!of_property_read_u32(node, "sync-on-green-active", &v))
	124	flags \|= v ? V4L2_MBUS_VIDEO_SOG_ACTIVE_HIGH :
	125	V4L2_MBUS_VIDEO_SOG_ACTIVE_LOW;
	126
99fd133f GL	127	bus->flags = flags;
	128
	129	}
99fd133f GL	130
	131	/**
	132	* v4l2_of_parse_endpoint() - parse all endpoint node properties
	133	* @node: pointer to endpoint device_node
	134	* @endpoint: pointer to the V4L2 OF endpoint data structure
	135	*
	136	* All properties are optional. If none are found, we don't set any flags.
	137	* This means the port has a static configuration and no properties have
	138	* to be specified explicitly.
	139	* If any properties that identify the bus as parallel are found and
	140	* slave-mode isn't set, we set V4L2_MBUS_MASTER. Similarly, if we recognise
	141	* the bus as serial CSI-2 and clock-noncontinuous isn't set, we set the
	142	* V4L2_MBUS_CSI2_CONTINUOUS_CLOCK flag.
	143	* The caller should hold a reference to @node.
9ff889b6	144	*
698da18e SA	145	* NOTE: This function does not parse properties the size of which is
	146	* variable without a low fixed limit. Please use
	147	* v4l2_of_alloc_parse_endpoint() in new drivers instead.
	148	*
9ff889b6	149	* Return: 0.
99fd133f	150	*/
9ff889b6 LP	151	int v4l2_of_parse_endpoint(const struct device_node *node,
9ff889b6 LP	152	struct v4l2_of_endpoint *endpoint)
99fd133f	153	{
b6eec1c4 SA	154	int rval;
b6eec1c4 SA	155
f2a575f6	156	of_graph_parse_endpoint(node, &endpoint->base);
161aadae SA	157	/* Zero fields from bus_type to until the end */
	158	memset(&endpoint->bus_type, 0, sizeof(*endpoint) -
	159	offsetof(typeof(*endpoint), bus_type));
99fd133f	160
b6eec1c4 SA	161	rval = v4l2_of_parse_csi_bus(node, endpoint);
	162	if (rval)
	163	return rval;
99fd133f GL	164	/*
	165	* Parse the parallel video bus properties only if none
	166	* of the MIPI CSI-2 specific properties were found.
	167	*/
	168	if (endpoint->bus.mipi_csi2.flags == 0)
	169	v4l2_of_parse_parallel_bus(node, endpoint);
	170
9ff889b6	171	return 0;
99fd133f GL	172	}
99fd133f GL	173	EXPORT_SYMBOL(v4l2_of_parse_endpoint);
c9bca8b3	174
698da18e SA	175	/*
	176	* v4l2_of_free_endpoint() - free the endpoint acquired by
	177	* v4l2_of_alloc_parse_endpoint()
	178	* @endpoint - the endpoint the resources of which are to be released
	179	*
	180	* It is safe to call this function with NULL argument or on an
	181	* endpoint the parsing of which failed.
	182	*/
	183	void v4l2_of_free_endpoint(struct v4l2_of_endpoint *endpoint)
	184	{
	185	if (IS_ERR_OR_NULL(endpoint))
	186	return;
	187
	188	kfree(endpoint->link_frequencies);
	189	kfree(endpoint);
	190	}
	191	EXPORT_SYMBOL(v4l2_of_free_endpoint);
	192
	193	/**
	194	* v4l2_of_alloc_parse_endpoint() - parse all endpoint node properties
	195	* @node: pointer to endpoint device_node
	196	*
	197	* All properties are optional. If none are found, we don't set any flags.
	198	* This means the port has a static configuration and no properties have
	199	* to be specified explicitly.
	200	* If any properties that identify the bus as parallel are found and
	201	* slave-mode isn't set, we set V4L2_MBUS_MASTER. Similarly, if we recognise
	202	* the bus as serial CSI-2 and clock-noncontinuous isn't set, we set the
	203	* V4L2_MBUS_CSI2_CONTINUOUS_CLOCK flag.
	204	* The caller should hold a reference to @node.
	205	*
	206	* v4l2_of_alloc_parse_endpoint() has two important differences to
	207	* v4l2_of_parse_endpoint():
	208	*
	209	* 1. It also parses variable size data and
	210	*
	211	* 2. The memory it has allocated to store the variable size data must
	212	* be freed using v4l2_of_free_endpoint() when no longer needed.
	213	*
	214	* Return: Pointer to v4l2_of_endpoint if successful, on error a
	215	* negative error code.
	216	*/
	217	struct v4l2_of_endpoint *v4l2_of_alloc_parse_endpoint(
	218	const struct device_node *node)
	219	{
	220	struct v4l2_of_endpoint *endpoint;
	221	int len;
	222	int rval;
	223
	224	endpoint = kzalloc(sizeof(*endpoint), GFP_KERNEL);
	225	if (!endpoint)
	226	return ERR_PTR(-ENOMEM);
	227
	228	rval = v4l2_of_parse_endpoint(node, endpoint);
	229	if (rval < 0)
	230	goto out_err;
	231
	232	if (of_get_property(node, "link-frequencies", &len)) {
	233	endpoint->link_frequencies = kmalloc(len, GFP_KERNEL);
	234	if (!endpoint->link_frequencies) {
	235	rval = -ENOMEM;
	236	goto out_err;
	237	}
	238
239	endpoint->nr_of_link_frequencies =
240	len / sizeof(*endpoint->link_frequencies);
241
242	rval = of_property_read_u64_array(
243	node, "link-frequencies", endpoint->link_frequencies,
244	endpoint->nr_of_link_frequencies);
245	if (rval < 0)
246	goto out_err;
247	}
248
249	return endpoint;
250
251	out_err:
252	v4l2_of_free_endpoint(endpoint);
253	return ERR_PTR(rval);
254	}
255	EXPORT_SYMBOL(v4l2_of_alloc_parse_endpoint);
256
c9bca8b3 LP	257	/**
	258	* v4l2_of_parse_link() - parse a link between two endpoints
	259	* @node: pointer to the endpoint at the local end of the link
	260	* @link: pointer to the V4L2 OF link data structure
	261	*
	262	* Fill the link structure with the local and remote nodes and port numbers.
	263	* The local_node and remote_node fields are set to point to the local and
	264	* remote port's parent nodes respectively (the port parent node being the
	265	* parent node of the port node if that node isn't a 'ports' node, or the
	266	* grand-parent node of the port node otherwise).
	267	*
	268	* A reference is taken to both the local and remote nodes, the caller must use
	269	* v4l2_of_put_link() to drop the references when done with the link.
	270	*
	271	* Return: 0 on success, or -ENOLINK if the remote endpoint can't be found.
	272	*/
	273	int v4l2_of_parse_link(const struct device_node *node,
	274	struct v4l2_of_link *link)
	275	{
	276	struct device_node *np;
	277
	278	memset(link, 0, sizeof(*link));
	279
	280	np = of_get_parent(node);
	281	of_property_read_u32(np, "reg", &link->local_port);
	282	np = of_get_next_parent(np);
	283	if (of_node_cmp(np->name, "ports") == 0)
	284	np = of_get_next_parent(np);
	285	link->local_node = np;
	286
	287	np = of_parse_phandle(node, "remote-endpoint", 0);
	288	if (!np) {
	289	of_node_put(link->local_node);
	290	return -ENOLINK;
	291	}
	292
	293	np = of_get_parent(np);
	294	of_property_read_u32(np, "reg", &link->remote_port);
	295	np = of_get_next_parent(np);
	296	if (of_node_cmp(np->name, "ports") == 0)
	297	np = of_get_next_parent(np);
	298	link->remote_node = np;
	299
	300	return 0;
	301	}
	302	EXPORT_SYMBOL(v4l2_of_parse_link);
	303
	304	/**
	305	* v4l2_of_put_link() - drop references to nodes in a link
	306	* @link: pointer to the V4L2 OF link data structure
	307	*
	308	* Drop references to the local and remote nodes in the link. This function must
	309	* be called on every link parsed with v4l2_of_parse_link().
	310	*/
	311	void v4l2_of_put_link(struct v4l2_of_link *link)
	312	{
	313	of_node_put(link->local_node);
	314	of_node_put(link->remote_node);
	315	}
	316	EXPORT_SYMBOL(v4l2_of_put_link);