Re: [PATCH/RFC 1/1] Add a libv4l plugin for Exynos4 camera

[Hans de Goede <hdegoede@redhat.com>]

Hi,

On 10/08/2014 10:46 AM, Jacek Anaszewski wrote:
> The plugin provides support for the media device on Exynos4 SoC.
> Added is also a media device configuration file parser.
> The media configuration file is used for conveying information
> about media device links that need to be established as well
> as V4L2 user control ioctls redirection to a particular
> sub-device.
> 
> The plugin performs single plane <-> multi plane API conversion,
> video pipeline linking and takes care of automatic data format
> negotiation for the whole pipeline, after intercepting
> VIDIOC_S_FMT or VIDIOC_TRY_FMT ioctls.
> 
> Signed-off-by: Jacek Anaszewski <j.anaszewski@samsung.com>
> Acked-by: Kyungmin Park <kyungmin.park@samsung.com>
> Cc: Mauro Carvalho Chehab <mchehab@osg.samsung.com>
> Cc: Hans Verkuil <hans.verkuil@cisco.com>
> ---
>  configure.ac                                       |    1 +
>  lib/Makefile.am                                    |    5 +-
>  lib/libv4l-exynos4-camera/Makefile.am              |    7 +
>  .../libv4l-devconfig-parser.h                      |  145 ++
>  lib/libv4l-exynos4-camera/libv4l-exynos4-camera.c  | 2486 ++++++++++++++++++++
>  5 files changed, 2642 insertions(+), 2 deletions(-)
>  create mode 100644 lib/libv4l-exynos4-camera/Makefile.am
>  create mode 100644 lib/libv4l-exynos4-camera/libv4l-devconfig-parser.h
>  create mode 100644 lib/libv4l-exynos4-camera/libv4l-exynos4-camera.c

Ugh, that is a big plugin. Can you please split out the parser stuff
into a separate file ?

> 
> diff --git a/configure.ac b/configure.ac
> index c9b0524..ae653b9 100644
> --- a/configure.ac
> +++ b/configure.ac
> @@ -17,6 +17,7 @@ AC_CONFIG_FILES([Makefile
>  	lib/libdvbv5/Makefile
>  	lib/libv4l2rds/Makefile
>  	lib/libv4l-mplane/Makefile
> +	lib/libv4l-exynos4-camera/Makefile
>  
>  	utils/Makefile
>  	utils/libv4l2util/Makefile
> diff --git a/lib/Makefile.am b/lib/Makefile.am
> index 3a0e19c..29455ab 100644
> --- a/lib/Makefile.am
> +++ b/lib/Makefile.am
> @@ -3,9 +3,10 @@ SUBDIRS = \
>  	libv4l2 \
>  	libv4l1 \
>  	libv4l2rds \
> -	libv4l-mplane
> +	libv4l-mplane \
> +	libv4l-exynos4-camera
>  
>  if LINUX_OS
>  SUBDIRS += \
>  	libdvbv5
> -endif
> \ No newline at end of file
> +endif
> diff --git a/lib/libv4l-exynos4-camera/Makefile.am b/lib/libv4l-exynos4-camera/Makefile.am
> new file mode 100644
> index 0000000..3552ec8
> --- /dev/null
> +++ b/lib/libv4l-exynos4-camera/Makefile.am
> @@ -0,0 +1,7 @@
> +if WITH_V4L_PLUGINS
> +libv4l2plugin_LTLIBRARIES = libv4l-exynos4-camera.la
> +endif
> +
> +libv4l_exynos4_camera_la_SOURCES = libv4l-exynos4-camera.c
> +libv4l_exynos4_camera_la_CPPFLAGS = -fvisibility=hidden -std=gnu99
> +libv4l_exynos4_camera_la_LDFLAGS = -avoid-version -module -shared -export-dynamic -lpthread
> diff --git a/lib/libv4l-exynos4-camera/libv4l-devconfig-parser.h b/lib/libv4l-exynos4-camera/libv4l-devconfig-parser.h
> new file mode 100644
> index 0000000..c56a469
> --- /dev/null
> +++ b/lib/libv4l-exynos4-camera/libv4l-devconfig-parser.h
> @@ -0,0 +1,145 @@
> +/*
> + * Parser of media device configuration file.
> + *
> + * Copyright (c) 2014 Samsung Electronics Co., Ltd.
> + *              http://www.samsung.com
> + *
> + * Author: Jacek Anaszewski <j.anaszewski@samsung.com>
> + *
> + * The configuration file has to comply with following format:
> + *
> + * Link description entry format:
> + *
> + * link {
> + * <TAB>source_entity: <entity_name><LF>
> + * <TAB>source_pad: <pad_id><LF>
> + * <TAB>sink_entity: <entity_name><LF>
> + * <TAB>sink_pad: <pad_id><LF>
> + * }
> + *
> + * The V4L2 control group format:
> + *
> + * v4l2-controls {
> + * <TAB><control1_name>: <entity_name><LF>
> + * <TAB><control2_name>: <entity_name><LF>
> + * ...
> + * <TAB><controlN_name>: <entity_name><LF>
> + * }
> + *
> + * Example:
> + *
> + * link {
> + *         source_entity: s5p-mipi-csis.0
> + *         source_pad: 1
> + *         sink_entity: FIMC.0
> + *         sink_pad: 0
> + * }
> + *
> + * v4l2-controls {
> + *         Color Effects: S5C73M3
> + *         Saturation: S5C73M3
> + * }
> + *
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU Lesser General Public License as published by
> + * the Free Software Foundation; either version 2.1 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> + * Lesser General Public License for more details.
> + */
> +
> +#ifndef LIBV4L_DEVCONFIG_PARSER_H
> +	#define LIBV4L_DEVCONFIG_PARSER_H
> +
> +#include <libv4l2.h>
> +
> +#ifdef DEBUG
> +#define V4L2_DEVCFG_PARSER_DBG(format, ARG...)\
> +	printf("[%s:%d] [%s] " format " \n", __FILE__, __LINE__, __func__, ##ARG)
> +#else
> +#define V4L2_DEVCFG_PARSER_DBG(format, ARG...)
> +#endif
> +
> +#define V4L2_DEVCFG_PARSER_ERR(format, ARG...)\
> +	fprintf(stderr, "Libv4l device config parser: "format "\n", ##ARG)
> +
> +#define V4L2_DEVCFG_PARSER_LOG(format, ARG...)\
> +	fprintf(stdout, "Libv4l device config parser: "format "\n", ##ARG)
> +
> +#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
> +
> +/*
> + * struct libv4l_media_link_conf - media entity link configuration
> + * @source_entity:	source entity of the link
> + * @source_pad:		source pad id
> + * @sink_entity:	sink entity of the link
> + * @sink_pad:		sink pad id
> + * @next:		pointer to the next data structure in the list
> + */
> +struct libv4l_media_link_conf {
> +	char *source_entity;
> +	int source_pad;
> +	char *sink_entity;
> +	int sink_pad;
> +	struct libv4l_media_link_conf *next;
> +};
> +
> +/*
> + * struct libv4l_media_ctrl_conf - user control to media entity configuration
> + * @control_name:	user control name
> + * @entity_name:	media entity name
> + * @entity:		media entity matched by entity_name
> + * @cid:		user control id
> + * @next:		pointer to the next data structure in the list
> + */
> +struct libv4l_media_ctrl_conf {
> +	char *control_name;
> +	char *entity_name;
> +	struct media_entity *entity;
> +	int cid;
> +	struct libv4l_media_ctrl_conf *next;
> +};
> +
> +/*
> + * struct libv4l_media_device_conf - media device config
> + * @links:	media entity link config
> + * @controls:	user control to media entity config
> + */
> +struct libv4l_media_device_conf {
> +	struct libv4l_media_link_conf *links;
> +	struct libv4l_media_ctrl_conf *controls;
> +};
> +
> +/*
> + * struct libv4l_conf_parser_ctx - parser context
> + * @line_start_pos:	start position of the current line in the file buffer
> + * @line_end:		end position of the current line in the file buffer
> + * @buf_pos:		file buffer position of the currently analyzed character
> + * @buf:		config file buffer
> + * @buf_size:		number of characters in the file buffer
> + */
> +struct libv4l_conf_parser_ctx {
> +	int line_start_pos;
> +	int line_end_pos;
> +	int buf_pos;
> +	char *buf;
> +	int buf_size;
> +};
> +
> +/*
> + * Read configuration file and initialize config argument with the parsed data.
> + * The config's links and controls fields must be released with use of
> + * libv4l_media_conf_release_links and libv4l_media_conf_release_controls
> + * functions respectively.
> + */
> +int libv4l_media_conf_read(char *fname, struct libv4l_media_device_conf *config);
> +
> +void libv4l_media_conf_release_links(struct libv4l_media_link_conf *cfg);
> +
> +void libv4l_media_conf_release_controls(struct libv4l_media_ctrl_conf *cfg);
> +
> +#endif /* LIBV4L_DEVCONFIG_PARSER_H */
> diff --git a/lib/libv4l-exynos4-camera/libv4l-exynos4-camera.c b/lib/libv4l-exynos4-camera/libv4l-exynos4-camera.c
> new file mode 100644
> index 0000000..d6956d5
> --- /dev/null
> +++ b/lib/libv4l-exynos4-camera/libv4l-exynos4-camera.c
> @@ -0,0 +1,2486 @@
> +/*
> + * Copyright (c) 2014 Samsung Electronics Co., Ltd.
> + *              http://www.samsung.com
> + *
> + * Author: Jacek Anaszewski <j.anaszewski@samsung.com>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU Lesser General Public License as published by
> + * the Free Software Foundation; either version 2.1 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> + * Lesser General Public License for more details.
> + */
> +
> +#include <config.h>
> +#include <errno.h>
> +#include <fcntl.h>
> +#include <linux/kdev_t.h>
> +#include <linux/media.h>
> +#include <linux/types.h>
> +#include <linux/v4l2-subdev.h>
> +#include <linux/videodev2.h>
> +#include <stdint.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <unistd.h>
> +#include <sys/ioctl.h>
> +#include <sys/stat.h>
> +#include <sys/syscall.h>
> +
> +#include "libv4l-devconfig-parser.h"
> +#include "libv4l-plugin.h"
> +
> +#define SYS_IOCTL(fd, cmd, arg) \
> +	syscall(SYS_ioctl, (int)(fd), (unsigned long)(cmd), (void *)(arg))
> +
> +#ifdef DEBUG
> +#define V4L2_EXYNOS4_DBG(format, ARG...)\
> +	printf("[%s:%d] [%s] " format " \n", __FILE__, __LINE__, __func__, ##ARG)
> +#else
> +#define V4L2_EXYNOS4_DBG(format, ARG...)
> +#endif
> +
> +#define V4L2_EXYNOS4_ERR(format, ARG...)\
> +	fprintf(stderr, "Libv4l Exynos4 camera plugin: "format "\n", ##ARG)
> +
> +#define V4L2_EXYNOS4_LOG(format, ARG...)\
> +	fprintf(stdout, "Libv4l Exynos4 camera plugin: "format "\n", ##ARG)
> +
> +#define SIMPLE_CONVERT_IOCTL(fd, cmd, arg, __struc) ({          \
> +	int __ret;                                              \
> +	struct __struc *req = arg;                              \
> +	uint32_t type = req->type;                              \
> +	req->type = convert_type(type);                         \
> +	__ret = SYS_IOCTL(fd, cmd, arg);                        \
> +	req->type = type;                                       \
> +	__ret;                                                  \
> +	})
> +
> +
> +#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
> +
> +#if HAVE_VISIBILITY
> +#define PLUGIN_PUBLIC __attribute__ ((visibility("default")))
> +#else
> +#define PLUGIN_PUBLIC
> +#endif
> +
> +#define EXYNOS4_FIMC_DRV	"exynos4-fimc"
> +#define EXYNOS4_FIMC_LITE_DRV	"exynos-fimc-lit"
> +#define EXYNOS4_FIMC_IS_ISP_DRV	"exynos4-fimc-is"
> +#define ENTITY_CAPTURE_SEGMENT	"capture"
> +#define EXYNOS4_CAPTURE_CONF	"/var/lib/libv4l/exynos4_capture_conf"
> +#define EXYNOS4_FIMC_IS_ISP	"FIMC-IS-ISP"
> +#define EXYNOS4_FIMC_PREFIX	"FIMC."
> +#define MAX_FMT_NEGO_NUM	50
> +
> +#define RGB_PX_FMT (1 << 1)
> +#define YUV_PX_FMT (1 << 2)
> +#define JPEG_PX_FMT (1 << 3)
> +#define SENSOR_PX_FMT (1 << 4)
> +
> +/*
> + * struct mbus_code_meta_pkg - media bus format meta package
> + * @name:		media bus code name
> + * @code:		media bus code
> + * @compat_pix_fmts:	pixel formats compatible with this mbus code
> + * @supported:		indicates if the code is supported by all entities
> +			in the pipeline
> + */
> +struct mbus_code_meta_pkg {
> +	const char *name;
> +	enum v4l2_mbus_pixelcode code;
> +	int compat_pix_fmts;
> +	int supported;
> +};
> +
> +struct mbus_code_meta_pkg mbus_codes[] = {
> +	/* RGB */
> +	{"RGB444_2X8_PADHI_BE", 0x1001, RGB_PX_FMT},
> +	{"RGB444_2X8_PADHI_LE", 0x1002, RGB_PX_FMT},
> +	{"RGB555_2X8_PADHI_BE", 0x1003, RGB_PX_FMT},
> +	{"RGB555_2X8_PADHI_LE", 0x1004, RGB_PX_FMT},
> +	{"BGR565_2X8_BE", 0x1005, RGB_PX_FMT},
> +	{"BGR565_2X8_LE", 0x1006, RGB_PX_FMT},
> +	{"RGB565_2X8_BE", 0x1007, RGB_PX_FMT},
> +	{"RGB565_2X8_LE", 0x1008, RGB_PX_FMT},
> +
> +	/* YUV (including grey) */
> +	{"Y8_1X8", 0x2001, RGB_PX_FMT | YUV_PX_FMT},
> +	{"UYVY8_1_5X8", 0x2002, RGB_PX_FMT | YUV_PX_FMT},
> +	{"VYUY8_1_5X8", 0x2003, RGB_PX_FMT | YUV_PX_FMT},
> +	{"YUYV8_1_5X8", 0x2004, RGB_PX_FMT | YUV_PX_FMT},
> +	{"YVYU8_1_5X8", 0x2005, RGB_PX_FMT | YUV_PX_FMT},
> +	{"UYVY8_2X8", 0x2006, RGB_PX_FMT | YUV_PX_FMT},
> +	{"VYUY8_2X8", 0x2007, RGB_PX_FMT | YUV_PX_FMT},
> +	{"YUYV8_2X8", 0x2008, RGB_PX_FMT | YUV_PX_FMT},
> +	{"YVYU8_2X8", 0x2009, RGB_PX_FMT | YUV_PX_FMT},
> +	{"Y10_1X10", 0x200a, RGB_PX_FMT | YUV_PX_FMT},
> +	{"YUYV10_2X10", 0x200b, RGB_PX_FMT | YUV_PX_FMT},
> +	{"YVYU10_2X10", 0x200c, RGB_PX_FMT | YUV_PX_FMT},
> +	{"Y12_1X12", 0x2013, RGB_PX_FMT | YUV_PX_FMT},
> +	{"UYVY8_1X16", 0x200f, RGB_PX_FMT | YUV_PX_FMT},
> +	{"VYUY8_1X16", 0x2010, RGB_PX_FMT | YUV_PX_FMT},
> +	{"YUYV8_1X16", 0x2011, RGB_PX_FMT | YUV_PX_FMT},
> +	{"YVYU8_1X16", 0x2012, RGB_PX_FMT | YUV_PX_FMT},
> +	{"YUYV10_1X20", 0x200d, RGB_PX_FMT | YUV_PX_FMT},
> +	{"YVYU10_1X20", 0x200e, RGB_PX_FMT | YUV_PX_FMT},
> +	{"YUV10_1X30", 0x2016, RGB_PX_FMT | YUV_PX_FMT},
> +
> +	/* Bayer */
> +	{"SBGGR8_1X8", 0x3001, RGB_PX_FMT},
> +	{"SGBRG8_1X8", 0x3013, RGB_PX_FMT},
> +	{"SGRBG8_1X8", 0x3002, RGB_PX_FMT},
> +	{"SRGGB8_1X8", 0x3014, RGB_PX_FMT},
> +	{"SBGGR10_DPCM8_1X8", 0x300b, RGB_PX_FMT},
> +	{"SGBRG10_DPCM8_1X8", 0x300c, RGB_PX_FMT},
> +	{"SGRBG10_DPCM8_1X8", 0x3009, RGB_PX_FMT},
> +	{"SRGGB10_DPCM8_1X8", 0x300d, RGB_PX_FMT},
> +	{"SBGGR10_2X8_PADHI_BE", 0x3003, RGB_PX_FMT},
> +	{"SBGGR10_2X8_PADHI_LE", 0x3004, RGB_PX_FMT},
> +	{"SBGGR10_2X8_PADLO_BE", 0x3005, RGB_PX_FMT},
> +	{"SBGGR10_2X8_PADLO_LE", 0x3006, RGB_PX_FMT},
> +	{"SBGGR10_1X10", 0x3007, RGB_PX_FMT},
> +	{"SGBRG10_1X10", 0x300e, RGB_PX_FMT},
> +	{"SGRBG10_1X10", 0x300a, RGB_PX_FMT},
> +	{"SRGGB10_1X10", 0x300f, RGB_PX_FMT},
> +	{"SBGGR12_1X12", 0x3008, RGB_PX_FMT},
> +	{"SGBRG12_1X12", 0x3010, RGB_PX_FMT},
> +	{"SGRBG12_1X12", 0x3011, RGB_PX_FMT},
> +	{"SRGGB12_1X12", 0x3012, RGB_PX_FMT},
> +
> +	/* JPEG compressed formats */
> +	{"JPEG_1X8", 0x4001, JPEG_PX_FMT},
> +
> +	/* S5C73M3 sensor specific interleaved UYVY and JPEG */
> +	{"S5C_UYVY_JPEG_1X8", 0x5001, SENSOR_PX_FMT},
> +
> +};
> +
> +unsigned int rgb_px_fmt[] = {
> +	V4L2_PIX_FMT_RGB565,
> +	V4L2_PIX_FMT_BGR666,
> +	V4L2_PIX_FMT_BGR32,
> +	V4L2_PIX_FMT_RGB555,
> +	V4L2_PIX_FMT_RGB444
> +};
> +
> +unsigned int yuv_px_fmt[] = {
> +	V4L2_PIX_FMT_YUYV,
> +	V4L2_PIX_FMT_UYVY,
> +	V4L2_PIX_FMT_VYUY,
> +	V4L2_PIX_FMT_YVYU,
> +	V4L2_PIX_FMT_YUV422P,
> +	V4L2_PIX_FMT_NV16,
> +	V4L2_PIX_FMT_NV61,
> +	V4L2_PIX_FMT_YUV420,
> +	V4L2_PIX_FMT_NV12,
> +	V4L2_PIX_FMT_NV12M,
> +	V4L2_PIX_FMT_YUV420M,
> +	V4L2_PIX_FMT_NV12M,
> +	V4L2_PIX_FMT_NV12MT
> +};
> +
> +unsigned int jpeg_px_fmt[] = { V4L2_PIX_FMT_JPEG };
> +
> +unsigned int sensor_px_fmt[] = { V4L2_PIX_FMT_S5C_UYVY_JPG };
> +
> +/*
> + * struct media_entity - media device entity data
> + * @id:			media entity id within media controller
> + * @name:		media entity name
> + * @node_name:		media entity related device node name
> + * @pads:		array of media_entity pads
> + * @num_pads:		number of elements in the pads array
> + * @links:		array of media_entity links
> + * @num_links:		number of elements in the links array
> + * @subdev_fmt:		related sub-device format
> + * @fd:			related sub-device node file descriptor
> + */
> +struct media_entity {
> +	int id;
> +	char name[32];
> +	char node_name[32];
> +	struct media_pad_desc *pads;
> +	int num_pads;
> +	struct media_link_desc *links;
> +	int num_links;
> +	struct v4l2_subdev_format subdev_fmt;
> +	int fd;
> +	int src_pad_id;
> +	int sink_pad_id;
> +	struct media_entity *next;
> +};
> +
> +/*
> + * struct media_device
> + * @entities:		media entities comprised by a video device
> + * @num_entities:	number of media entities within a video device
> + * @pipeline:		pipeline of media entities from sensor to the video node
> + * @media_fd:		file descriptor of the media device this
> + *			video device belongs to
> + */
> +struct media_device {
> +	struct media_entity *entities;
> +	int num_entities;
> +	struct media_entity *pipeline;
> +	int media_fd;
> +};
> +
> +/*
> + * struct exynos4_camera_plugin - libv4l exynos4 camera plugin
> + * @config:		configuration data for the plugin
> + * @vid_fd:		video device node file descriptor
> + * @mdev:		media device comprising the vid_fd related video device
> + */
> +struct exynos4_camera_plugin {
> +	struct libv4l_media_device_conf config;
> +	int vid_fd;
> +	struct media_device mdev;
> +};
> +
> +/*---------- Media Device configuration parser -------------*/
> +
> +static int get_line(struct libv4l_conf_parser_ctx *ctx)
> +{
> +	int i;
> +
> +	if (ctx->buf_pos == ctx->buf_size)
> +		return -EINVAL;
> +
> +	ctx->line_start_pos = ctx->buf_pos;
> +
> +	for (i = ctx->buf_pos; i < ctx->buf_size; ++i) {
> +		if (ctx->buf[i] == '\n') {
> +			ctx->buf_pos = i + 1;
> +			break;
> +		}
> +	}
> +
> +	ctx->line_end_pos = i - 1;
> +
> +	return 0;
> +}
> +
> +static int parse_field_value(struct libv4l_conf_parser_ctx *ctx,
> +				const char *field_name, char **field_value)
> +{
> +	char *value;
> +	int line_offset = ctx->line_start_pos, i;
> +	char *line_buf = ctx->buf + line_offset;
> +	int field_name_len = strlen(field_name);
> +	int field_value_pos = field_name_len + 3;
> +	int field_value_len = ctx->line_end_pos - line_offset
> +	    - field_value_pos + 1;
> +
> +	if (line_buf[0] != '\t') {
> +		V4L2_DEVCFG_PARSER_ERR("Lack of leading tab.");
> +		return -EINVAL;
> +	}
> +
> +	if (strncmp(line_buf + 1, field_name, field_name_len) != 0) {
> +		V4L2_DEVCFG_PARSER_ERR("Invalid field name.");
> +		return -EINVAL;
> +	}
> +
> +	if (line_buf[field_value_pos - 1] != ' ') {
> +		V4L2_DEVCFG_PARSER_ERR("Lack of space after colon.");
> +		return -EINVAL;
> +	}
> +
> +	for (i = 0; i < field_value_len; ++i)
> +		if (line_buf[field_value_pos + i] == ' ') {
> +			V4L2_DEVCFG_PARSER_ERR("Field value must not include spaces.");
> +			return -EINVAL;
> +		}
> +
> +	value = malloc(sizeof(char) * (field_value_len + 1));
> +	if (value == NULL)
> +		return -ENOMEM;
> +
> +	strncpy(value, line_buf + field_value_pos, field_value_len);
> +	value[field_value_len] = '\0';
> +
> +	*field_value = value;
> +
> +	return 0;
> +}
> +
> +static int parse_link(struct libv4l_conf_parser_ctx *ctx,
> +			struct libv4l_media_link_conf **link)
> +{
> +	int *l_start = &ctx->line_start_pos, i;
> +	int *l_end = &ctx->line_end_pos;
> +	struct libv4l_media_link_conf *ret_link = NULL;
> +	int ret;
> +	static const char *link_fields[] = {
> +		"source_entity",
> +		"source_pad",
> +		"sink_entity",
> +		"sink_pad"
> +	};
> +	char *field_values[4];
> +
> +	memset(field_values, 0, sizeof(field_values));
> +
> +	ctx->line_start_pos = 0;
> +	ctx->line_end_pos = 0;
> +
> +	/* look for link beginning signature */
> +	for (;;) {
> +		ret = get_line(ctx);
> +		if (ret < 0)
> +			goto err_parser;
> +
> +		/* handling empty line case */
> +		if (*l_end - *l_start <= 1)
> +			continue;
> +
> +		ret = strncmp(ctx->buf + *l_start,
> +			      "link {\n", *l_end - *l_start);
> +		if (ret == 0)
> +			break;
> +	}
> +
> +	/* read link fields */
> +	for (i = 0; i < ARRAY_SIZE(link_fields); ++i) {
> +		ret = get_line(ctx);
> +		if (ret < 0) {
> +			V4L2_DEVCFG_PARSER_ERR("Link entry incomplete.");
> +			goto err_parser;
> +		}
> +
> +		ret = parse_field_value(ctx, link_fields[i], &field_values[i]);
> +		if (ret < 0) {
> +			V4L2_DEVCFG_PARSER_ERR("Link field format error (%s)",
> +					 link_fields[i]);
> +			goto err_parser;
> +		}
> +	}
> +
> +	/* look for link end */
> +	ret = get_line(ctx);
> +	if (ret < 0) {
> +		V4L2_DEVCFG_PARSER_ERR("EOF reached, link end not found.");
> +		goto err_parser;
> +	}
> +
> +	if (ctx->buf[*l_start] != '}') {
> +		V4L2_DEVCFG_PARSER_ERR("Link closing marker not found");
> +		goto err_parser;
> +	}
> +
> +	ret_link = malloc(sizeof(struct libv4l_media_link_conf));
> +	if (ret_link == NULL) {
> +		V4L2_DEVCFG_PARSER_ERR("Could not allocate memory for a link.");
> +		goto err_parser;
> +	}
> +
> +	ret_link->source_entity = field_values[0];
> +	ret_link->source_pad = atoi(field_values[1]);
> +	ret_link->sink_entity = field_values[2];
> +	ret_link->sink_pad = atoi(field_values[3]);
> +
> +	free(field_values[1]);
> +	free(field_values[3]);
> +
> +	*link = ret_link;
> +
> +	return 1;
> +
> +err_parser:
> +	for (i = 0; i < ARRAY_SIZE(field_values); ++i) {
> +		if (field_values[i] != NULL)
> +			free(field_values[i]);
> +	}
> +
> +	if (ret_link != NULL)
> +		free(ret_link);
> +
> +	return 0;
> +}
> +
> +static int parse_property(struct libv4l_conf_parser_ctx *ctx,
> +				char **key, char **value)
> +{
> +	int line_offset = ctx->line_start_pos,
> +	    line_length = ctx->line_end_pos - ctx->line_start_pos + 1,
> +	    val_length, i;
> +	char *line_buf = ctx->buf + line_offset, *k, *v;
> +
> +	if (line_buf[0] != '\t') {
> +		V4L2_DEVCFG_PARSER_ERR("Lack of leading tab.");
> +		return -EINVAL;
> +	}
> +
> +	/* Parse key segment of a property */
> +	for (i = 1; i < line_length; ++i)
> +		if (line_buf[i] == ':')
> +			break;
> +
> +	if (i == line_length) {
> +		V4L2_DEVCFG_PARSER_ERR("Property format error - lack of semicolon");
> +		return -EINVAL;
> +	}
> +
> +	/* At least one character should be left for value segment */
> +	if (i >= line_length - 2) {
> +		V4L2_DEVCFG_PARSER_ERR("Property format error - no value segment");
> +		return -EINVAL;
> +	}
> +
> +	k = malloc(sizeof(char) * i);
> +	if (k == NULL)
> +		return -ENOMEM;
> +
> +	strncpy(k, line_buf + 1, i - 1);
> +	k[i - 1] = '\0';
> +
> +	val_length = line_length - i - 2;
> +
> +	v = malloc(sizeof(char) * (val_length + 1));
> +	if (v == NULL)
> +		return -ENOMEM;
> +
> +	strncpy(v, line_buf + i + 2, val_length);
> +	v[val_length] = '\0';
> +
> +	*key = k;
> +	*value = v;
> +
> +	return 0;
> +}
> +
> +static int parse_controls(struct libv4l_conf_parser_ctx *ctx,
> +				struct libv4l_media_ctrl_conf **controls)
> +{
> +	int *l_start = &ctx->line_start_pos;
> +	int *l_end = &ctx->line_end_pos;
> +	struct libv4l_media_ctrl_conf *head = NULL, *tmp_ctrl, *c = NULL;
> +	int ret;
> +	char *control_name = NULL, *entity_name = NULL;
> +
> +	if (controls == NULL)
> +		return -EINVAL;
> +
> +	ctx->buf_pos = 0;
> +	ctx->line_start_pos = 0;
> +	ctx->line_end_pos = 0;
> +
> +	/* look for controls beginning signature */
> +	for (;;) {
> +		ret = get_line(ctx);
> +		if (ret < 0) {
> +			V4L2_DEVCFG_PARSER_LOG("Controls configuration not found");
> +			return 0;
> +		}
> +
> +		/* handling empty line case */
> +		if (*l_end - *l_start <= 1)
> +			continue;
> +
> +		ret = strncmp(ctx->buf + *l_start,
> +			      "v4l2-controls {\n", *l_end - *l_start);
> +		if (ret == 0)
> +			break;
> +	}
> +
> +	/* read control-entity pairs */
> +	for (;;) {
> +		ret = get_line(ctx);
> +		if (ret < 0) {
> +			V4L2_DEVCFG_PARSER_ERR("Controls closing marker not found");
> +			goto err_parser;
> +		}
> +
> +		if (ctx->buf[*l_start] == '}')
> +			break;
> +
> +		ret = parse_property(ctx, &control_name, &entity_name);
> +		if (ret < 0) {
> +			V4L2_DEVCFG_PARSER_ERR("Control property parsing error");
> +			goto err_parser;
> +		}
> +
> +		tmp_ctrl = calloc(1, sizeof(*tmp_ctrl));
> +		if (tmp_ctrl == NULL) {
> +			ret = -ENOMEM;
> +			goto err_parser;
> +		}
> +
> +		tmp_ctrl->entity_name = entity_name;
> +		tmp_ctrl->control_name = control_name;
> +
> +		if (head == NULL) {
> +			head = tmp_ctrl;
> +			c = head;
> +		} else {
> +			c->next = tmp_ctrl;
> +			c = c->next;
> +		}
> +	}
> +
> +	*controls = head;
> +
> +	return 0;
> +
> +err_parser:
> +	libv4l_media_conf_release_controls(head);
> +	return ret;
> +}
> +
> +static int parse_links(struct libv4l_conf_parser_ctx *ctx,
> +			struct libv4l_media_link_conf **links)
> +{
> +	int cnt = 0;
> +	struct libv4l_media_link_conf *l = NULL, *head = NULL, *tmp = NULL;
> +
> +	ctx->line_start_pos = 0;
> +	ctx->buf_pos = 0;
> +
> +	while (parse_link(ctx, &tmp)) {
> +		if (head == NULL) {
> +			head = tmp;
> +			head->next = NULL;
> +			l = head;
> +		} else {
> +			l->next = tmp;
> +			l = l->next;
> +			l->next = NULL;
> +		}
> +		++cnt;
> +	}
> +
> +	if (cnt == 0) {
> +		V4L2_DEVCFG_PARSER_ERR("No links have been found!");
> +		goto err_no_data;
> +	}
> +
> +	*links = head;
> +
> +	return 0;
> +
> +err_no_data:
> +	libv4l_media_conf_release_links(head);
> +	return -EINVAL;
> +
> +}
> +
> +void libv4l_media_conf_release_links(struct libv4l_media_link_conf *cfg)
> +{
> +	struct libv4l_media_link_conf *tmp;
> +
> +	while (cfg) {
> +		tmp = cfg->next;
> +		free(cfg->source_entity);
> +		free(cfg->sink_entity);
> +		free(cfg);
> +		cfg = tmp;
> +	}
> +}
> +
> +void libv4l_media_conf_release_controls(struct libv4l_media_ctrl_conf *cfg)
> +{
> +	struct libv4l_media_ctrl_conf *tmp;
> +
> +	while (cfg) {
> +		tmp = cfg->next;
> +		free(cfg->entity_name);
> +		free(cfg->control_name);
> +		free(cfg);
> +		cfg = tmp;
> +	}
> +}
> +
> +int libv4l_media_conf_read(char *fname, struct libv4l_media_device_conf *config)
> +{
> +	struct libv4l_media_link_conf *links;
> +	struct libv4l_media_ctrl_conf *controls = NULL;
> +	struct stat st;
> +	struct libv4l_conf_parser_ctx ctx;
> +	int fd, ret;
> +
> +	memset(&ctx, 0, sizeof(ctx));
> +
> +	/* read config file to a buffer */
> +
> +	fd = open(fname, O_RDONLY);
> +
> +	if (fd < 0) {
> +		V4L2_DEVCFG_PARSER_ERR("Could not open config file");
> +		return -EINVAL;
> +	}
> +
> +	ret = fstat(fd, &st);
> +	if (ret < 0) {
> +		V4L2_DEVCFG_PARSER_ERR("Could not get config file statistics");
> +		goto err_fstat;
> +	}
> +
> +	ctx.buf_size = st.st_size;
> +	ctx.buf = malloc(ctx.buf_size);
> +	if (ctx.buf == NULL) {
> +		V4L2_DEVCFG_PARSER_ERR("Could not allocate file buffer");
> +		ret = -ENOMEM;
> +		goto err_fstat;
> +	}
> +
> +	ret = read(fd, ctx.buf, ctx.buf_size);
> +	if (ret < 0)
> +		goto err_config_read;
> +
> +	/* parse file buffer */
> +
> +	ret = parse_links(&ctx, &links);
> +	if (ret < 0)
> +		goto err_config_read;
> +
> +	ret = parse_controls(&ctx, &controls);
> +	if (ret < 0)
> +		goto err_parse_controls;
> +
> +	config->links = links;
> +	config->controls = controls;
> +
> +	free(ctx.buf);
> +
> +	return ret;
> +
> +err_parse_controls:
> +	libv4l_media_conf_release_links(links);
> +err_config_read:
> +	if (ctx.buf != NULL)
> +		free(ctx.buf);
> +err_fstat:
> +	close(fd);
> +
> +	return ret;
> +}
> +
> +
> +/*---------- Dev node info helpers ----------*/
> +
> +static int get_node_by_devnum(unsigned int major, unsigned int minor,
> +				char *node_name)
> +{
> +	struct stat devstat;
> +	char devname[32];
> +	char sysname[32];
> +	char target[1024];
> +	char *p;
> +	int ret;
> +
> +	if (node_name == NULL)
> +		return -EINVAL;
> +
> +	sprintf(sysname, "/sys/dev/char/%u:%u", major, minor);
> +	ret = readlink(sysname, target, sizeof(target));
> +	if (ret < 0)
> +		return -EINVAL;
> +
> +	target[ret] = '\0';
> +	p = strrchr(target, '/');
> +	if (p == NULL)
> +		return -EINVAL;
> +
> +	sprintf(devname, "/dev/%s", p + 1);
> +	ret = stat(devname, &devstat);
> +	if (ret < 0)
> +		return -EINVAL;
> +
> +	if (major(devstat.st_rdev) == major &&
> +	    minor(devstat.st_rdev) == minor)
> +		strcpy(node_name, devname);
> +	else
> +		return -EINVAL;
> +
> +	return 0;
> +}
> +
> +static int get_node_by_fd(int fd, char *node_name)
> +{
> +	struct stat stat;
> +	int major_num, minor_num;
> +	int ret;
> +
> +	if (node_name == NULL)
> +		return -EINVAL;
> +
> +	ret = fstat(fd, &stat);
> +	if (ret < 0)
> +		return -EINVAL;
> +
> +	major_num = MAJOR(stat.st_rdev);
> +	minor_num = MINOR(stat.st_rdev);
> +
> +	ret = get_node_by_devnum(major_num, minor_num, node_name);
> +	if (ret < 0)
> +		return -EINVAL;
> +
> +	return 0;
> +}
> +
> +/*---------- Media controller API helpers ----------*/
> +
> +static int enumerate_entites(struct media_device *mdev)
> +{
> +	struct media_entity *entity, *entity_buf;
> +	struct media_entity_desc entity_desc;
> +	unsigned int entities_cnt = 0, entity_buf_size;
> +	int ret, id;
> +
> +	if (mdev == NULL)
> +		return -EINVAL;
> +
> +	entity_buf = calloc(1, sizeof(*entity));
> +	memset(&entity_desc, 0, sizeof(entity_desc));
> +
> +	for (id = 0;; id = entity_desc.id, ++entities_cnt) {
> +		entity_buf_size = (entities_cnt + 1) * sizeof(*entity);
> +		entity_buf = realloc(entity_buf, entity_buf_size);
> +
> +		entity = &entity_buf[entities_cnt];
> +		memset(entity, 0, sizeof(*entity));
> +
> +		entity_desc.id = id | MEDIA_ENT_ID_FLAG_NEXT;
> +		ret = SYS_IOCTL(mdev->media_fd, MEDIA_IOC_ENUM_ENTITIES,
> +			    &entity_desc);
> +		if (ret < 0) {
> +			ret = errno != EINVAL ? -errno : 0;
> +			break;
> +		}
> +		entity->id = entity_desc.id;
> +		entity->num_pads = entity_desc.pads;
> +		entity->num_links = entity_desc.links;
> +		strcpy(entity->name, entity_desc.name);
> +
> +		if (!(entity_desc.type & MEDIA_ENT_T_DEVNODE) &&
> +		    !(entity_desc.type & MEDIA_ENT_T_V4L2_SUBDEV))
> +			continue;
> +
> +		ret = get_node_by_devnum(entity_desc.v4l.major,
> +					 entity_desc.v4l.minor,
> +					 entity->node_name);
> +		if (ret < 0)
> +			goto err_media_dev;
> +	}
> +
> +	mdev->num_entities = entities_cnt;
> +	mdev->entities = entity_buf;
> +
> +	return ret;
> +
> +err_media_dev:
> +	free(entity_buf);
> +	return -EINVAL;
> +}
> +
> +static int enumerate_links(struct media_device *mdev)
> +{
> +	struct media_entity *entities = mdev->entities;
> +	struct media_links_enum links_enum;
> +	int i, j, ret;
> +
> +	if (mdev == NULL)
> +		return -EINVAL;
> +
> +	for (i = 0; i < mdev->num_entities; ++i) {
> +		if (entities[i].num_pads == 0)
> +			continue;
> +		links_enum.entity = entities[i].id;
> +		links_enum.pads = malloc(entities[i].num_pads *
> +					 sizeof(struct media_pad_desc));
> +		links_enum.links = malloc(entities[i].num_links *
> +					  sizeof(struct media_link_desc));
> +		ret = SYS_IOCTL(mdev->media_fd, MEDIA_IOC_ENUM_LINKS,
> +			    &links_enum);
> +		if (ret < 0) {
> +			ret = -errno;
> +			goto err_enum_links;
> +		}
> +
> +		entities[i].pads = links_enum.pads;
> +		entities[i].links = links_enum.links;
> +	}
> +
> +	return 0;
> +
> +err_enum_links:
> +	for (j = 0; j < i; ++j) {
> +		free(entities[j].pads);
> +		free(entities[j].links);
> +	}
> +
> +	return ret;
> +}
> +
> +static int release_entities(struct media_device *mdev)
> +{
> +	int i;
> +
> +	if (mdev == NULL)
> +		return -EINVAL;
> +
> +	for (i = 0; i < mdev->num_entities; ++i) {
> +		free(mdev->entities[i].links);
> +		free(mdev->entities[i].pads);
> +	}
> +
> +	free(mdev->entities);
> +
> +	return 0;
> +}
> +
> +static int get_device_topology(struct media_device *mdev)
> +{
> +	int ret;
> +
> +	if (mdev == NULL)
> +		return -EINVAL;
> +
> +	ret = enumerate_entites(mdev);
> +	if (ret < 0) {
> +		V4L2_EXYNOS4_ERR("Failed to enumerate video entities.");
> +		return ret;
> +	}
> +
> +	ret = enumerate_links(mdev);
> +	if (ret < 0) {
> +		V4L2_EXYNOS4_ERR("Failed to enumerate links.");
> +		return ret;
> +	}
> +
> +	return 0;
> +}
> +
> +static int has_device_node(struct media_device *mdev, char *entity_node,
> +		char **entity_name)
> +{
> +	int i;
> +
> +	if (mdev == NULL || entity_node == NULL || entity_name == NULL)
> +		return 0;
> +
> +	for (i = 0; i < mdev->num_entities; ++i) {
> +		if (strcmp(mdev->entities[i].node_name,
> +			   entity_node) == 0) {
> +			*entity_name = mdev->entities[i].name;
> +			return 1;
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +static int capture_entity(char *name)
> +{
> +	int cap_segment_pos;
> +
> +	if (name == NULL)
> +		return 0;
> +
> +	cap_segment_pos = strlen(name) - strlen(ENTITY_CAPTURE_SEGMENT);
> +
> +	if (strcmp(name + cap_segment_pos, ENTITY_CAPTURE_SEGMENT) == 0)
> +		return 1;
> +
> +	return 0;
> +}
> +
> +static int get_media_node(struct media_device *mdev, int capture_fd,
> +	       char **entity_name)
> +{
> +	char media_dev_node[32], capture_dev_node[32];
> +	int i, ret = 0;
> +
> +	if (mdev == NULL)
> +		return -EINVAL;
> +
> +	ret = get_node_by_fd(capture_fd, capture_dev_node);
> +	if (ret < 0)
> +		return -EINVAL;
> +
> +	/* query all available media devices */
> +	for (i = 0;; ++i) {
> +		sprintf(media_dev_node, "/dev/media%d", i);
> +
> +		mdev->media_fd = open(media_dev_node, O_RDWR);
> +		if (mdev->media_fd < 0) {
> +			close(mdev->media_fd);
> +			return -EINVAL;
> +		}
> +
> +		ret = get_device_topology(mdev);
> +		if (ret < 0)

You're leaking mdev->media_fd here.

> +			return ret;
> +
> +		if (has_device_node(mdev, capture_dev_node,
> +				    entity_name))
> +			return 0;
> +
> +		release_entities(mdev);
> +		close(mdev->media_fd);
> +	}
> +
> +	return -EINVAL;
> +}
> +
> +static int get_pad_parent_name(struct media_device *mdev,
> +		    struct media_pad_desc *pad, char **parent_name)
> +{
> +	int i;
> +
> +	if (mdev == NULL || pad == NULL || parent_name == NULL)
> +		return -EINVAL;
> +
> +	for (i = 0; i < mdev->num_entities; ++i) {
> +		if (mdev->entities[i].id == pad->entity) {
> +			*parent_name = mdev->entities[i].name;
> +			break;
> +		}
> +	}
> +
> +	if (i == mdev->num_entities)
> +		return -EINVAL;
> +
> +	return 0;
> +}
> +
> +static int entity_get_id_by_name(struct media_device *mdev, char *name, int *id)
> +{
> +	int i;
> +
> +	for (i = 0; i < mdev->num_entities; ++i) {
> +		if (strcmp(mdev->entities[i].name, name) == 0) {
> +			*id = mdev->entities[i].id;
> +			return 0;
> +		}
> +	}
> +
> +	return -EINVAL;
> +
> +}
> +
> +static int has_link_pad(struct media_link_desc *link,
> +			struct media_pad_desc *pad)
> +{
> +	if (link == NULL || pad == NULL)
> +		return -EINVAL;
> +
> +	if (link->source.entity == pad->entity &&
> +	    link->source.index == pad->index)
> +		return 1;
> +	if (link->sink.entity == pad->entity &&
> +	    link->sink.index == pad->index)
> +		return 1;
> +
> +	return 0;
> +}
> +
> +static int pad_busy(struct media_device *mdev, struct media_pad_desc *pad,
> +			struct media_link_desc **link)
> +{
> +	struct media_link_desc *cur_link;
> +	int i, j;
> +
> +	if (mdev == NULL || link == NULL)
> +		return -EINVAL;
> +
> +	for (i = 0; i < mdev->num_entities; ++i) {
> +		for (j = 0; j < mdev->entities[i].num_links; ++j) {
> +			cur_link = &mdev->entities[i].links[j];
> +			if ((cur_link->flags & MEDIA_LNK_FL_ENABLED) &&
> +			    has_link_pad(cur_link, pad)) {
> +				*link = cur_link;
> +				return 1;
> +			}
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +static int print_link_log(char *message, struct media_device *mdev,
> +				struct media_link_desc *link)
> +{
> +	char *src_entity = NULL, *sink_entity = NULL;
> +	int ret;
> +
> +	if (message == NULL || mdev == NULL || link == NULL)
> +		return -EINVAL;
> +
> +	ret = get_pad_parent_name(mdev, &link->source, &src_entity);
> +	if (ret < 0)
> +		return ret;
> +
> +	ret = get_pad_parent_name(mdev, &link->sink, &sink_entity);
> +	if (ret < 0)
> +		return ret;
> +
> +	V4L2_EXYNOS4_LOG("%s: [%s]:%d -> [%s]:%d",
> +	    message,
> +	    src_entity, link->source.index, sink_entity, link->sink.index);
> +
> +	return 0;
> +}
> +
> +static int disable_link(struct media_device *mdev, struct media_link_desc *link)
> +{
> +	int ret = -1;
> +
> +	if (mdev == NULL || link == NULL)
> +		return -EINVAL;
> +
> +	if (link->flags & MEDIA_LNK_FL_IMMUTABLE) {
> +		V4L2_EXYNOS4_ERR("Can't disable immutable link.");
> +		return -EINVAL;
> +	}
> +
> +	link->flags &= ~MEDIA_LNK_FL_ENABLED;
> +	ret = SYS_IOCTL(mdev->media_fd, MEDIA_IOC_SETUP_LINK, link);
> +	if (ret) {
> +		V4L2_EXYNOS4_ERR("MEDIA_IOC_SETUP_LINK ioctl failed.");
> +		return ret;
> +	}
> +
> +	print_link_log("Disabled link", mdev, link);
> +
> +	return 0;
> +}
> +
> +static int get_v4l2_pad(struct media_device *mdev, char *entity_name,
> +			int pad_id, struct media_pad_desc *pad)
> +{
> +	int ret = -1, entity_id;
> +
> +	if (mdev == NULL || entity_name == NULL || pad == NULL)
> +		return -EINVAL;
> +
> +	ret = entity_get_id_by_name(mdev, entity_name, &entity_id);
> +	if (ret < 0)
> +		return ret;
> +
> +	pad->entity = entity_id;
> +	pad->index = pad_id;
> +
> +	return 0;
> +}
> +
> +static int same_link(struct media_link_desc *link1,
> +			struct media_link_desc *link2)
> +{
> +	if (link1 == NULL || link2 == NULL)
> +		return 0;
> +
> +	if (link1->source.entity == link2->source.entity &&
> +	    link1->source.index == link2->source.index &&
> +	    link1->sink.entity == link2->sink.entity &&
> +	    link1->sink.index == link2->sink.index)
> +		return 1;
> +
> +	return 0;
> +}
> +
> +static int link_enabled(struct media_device *mdev,
> +			struct media_link_desc *link)
> +{
> +	struct media_link_desc *cur_link;
> +	int i, j;
> +
> +	if (mdev == NULL || link == NULL)
> +		return 0;
> +
> +	for (i = 0; i < mdev->num_entities; ++i) {
> +		for (j = 0; j < mdev->entities[i].num_links; ++j) {
> +			cur_link = &mdev->entities[i].links[j];
> +			if ((cur_link->flags & MEDIA_LNK_FL_ENABLED) &&
> +			    same_link(link, cur_link)) {
> +				return 1;
> +			}
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +static int get_entity_by_pad(struct media_device *mdev,
> +				struct media_pad_desc *pad,
> +				struct media_entity **entity)
> +{
> +	int i;
> +
> +	if (mdev == NULL || pad == NULL || entity == NULL)
> +		return -EINVAL;
> +
> +	    for (i = 0; i < mdev->num_entities; ++i) {
> +		if (pad->entity == mdev->entities[i].id) {
> +			*entity = &mdev->entities[i];
> +			return 0;
> +		}
> +	}
> +
> +	return -EINVAL;
> +}
> +
> +static int setup_config_links(struct media_device *mdev,
> +				struct libv4l_media_link_conf *links)
> +{
> +	struct media_link_desc new_link, *colliding_link;
> +	struct media_entity *entity;
> +	int i, ret;
> +
> +	if (mdev == NULL || links == NULL)
> +		return -EINVAL;
> +
> +	while (links) {
> +		ret = get_v4l2_pad(mdev, links->source_entity,
> +				   links->source_pad, &new_link.source);
> +		if (ret < 0)
> +			return ret;
> +		ret = get_v4l2_pad(mdev, links->sink_entity,
> +				   links->sink_pad, &new_link.sink);
> +		if (ret < 0)
> +			return ret;
> +
> +		if (link_enabled(mdev, &new_link)) {
> +			print_link_log("Link already enabled", mdev,
> +				       &new_link);
> +
> +			links = links->next;
> +			continue;
> +		}
> +
> +		ret = get_entity_by_pad(mdev, &new_link.sink, &entity);
> +		if (ret < 0)
> +			return ret;
> +
> +		/* Disable all links occupying sink pads of the entity */
> +		for (i = 0; i < entity->num_pads; ++i) {
> +			if (entity->pads[i].flags & MEDIA_PAD_FL_SINK) {
> +				if (pad_busy(mdev, &entity->pads[i],
> +							&colliding_link)) {
> +					ret = disable_link(mdev,
> +							colliding_link);
> +					if (ret < 0)
> +						return ret;
> +				}
> +			}
> +		}
> +
> +		new_link.flags = MEDIA_LNK_FL_ENABLED;
> +
> +		print_link_log("Linking entities", mdev, &new_link);
> +
> +		ret = SYS_IOCTL(mdev->media_fd, MEDIA_IOC_SETUP_LINK,
> +			    &new_link);
> +		if (ret < 0)
> +			return ret;
> +
> +		V4L2_EXYNOS4_LOG("Link has been set up successfuly.");
> +
> +		links = links->next;
> +	}
> +
> +	return 0;
> +}
> +
> +static struct media_entity *get_entity_by_name(struct media_device *mdev,
> +						char *name)
> +{
> +	int i;
> +
> +	for (i = 0; i < mdev->num_entities; ++i)
> +		if (!strcmp(mdev->entities[i].name, name))
> +			return &mdev->entities[i];
> +
> +	return NULL;
> +}
> +
> +/*
> + * If there was an entry for the cid defined in the controls
> + * config then this function returns related entity. Otherwise
> + * NULL is returned.
> + */
> +static struct media_entity *get_entity_by_cid(
> +				struct libv4l_media_ctrl_conf *ctrl_cfg,
> +				int cid)
> +{
> +	if (ctrl_cfg == NULL)
> +		return NULL;
> +
> +	while (ctrl_cfg) {
> +		if (ctrl_cfg->cid == cid)
> +			return ctrl_cfg->entity;
> +		ctrl_cfg = ctrl_cfg->next;
> +	}
> +
> +	return NULL;
> +}
> +
> +static int is_control_supported(struct media_device *mdev,
> +			struct libv4l_media_ctrl_conf *ctrl_cfg)
> +{
> +	struct v4l2_query_ext_ctrl queryctrl;
> +	struct media_entity *entity;
> +
> +	entity = get_entity_by_name(mdev, ctrl_cfg->entity_name);
> +	if (entity == NULL)
> +		return 0;
> +
> +	/* Iterate through control ids */
> +
> +	queryctrl.id = V4L2_CID_BASE | V4L2_CTRL_FLAG_NEXT_CTRL;
> +
> +	while (!SYS_IOCTL(entity->fd, VIDIOC_QUERY_EXT_CTRL, &queryctrl)) {
> +		if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED)
> +			continue;
> +
> +		if (!strcmp((char *) queryctrl.name, ctrl_cfg->control_name)) {
> +			ctrl_cfg->cid = queryctrl.id &
> +					~V4L2_CTRL_FLAG_NEXT_CTRL;
> +			ctrl_cfg->entity = entity;
> +
> +			return 1;
> +		}
> +
> +		queryctrl.id = queryctrl.id | V4L2_CTRL_FLAG_NEXT_CTRL;
> +	}
> +
> +	queryctrl.id = V4L2_CID_BASE | V4L2_CTRL_FLAG_NEXT_COMPOUND;
> +
> +	while (!SYS_IOCTL(entity->fd, VIDIOC_QUERY_EXT_CTRL, &queryctrl)) {
> +		if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED)
> +			continue;
> +
> +		if (!strcmp((char *) queryctrl.name, ctrl_cfg->control_name)) {
> +			ctrl_cfg->cid = queryctrl.id &
> +					~V4L2_CTRL_FLAG_NEXT_COMPOUND;
> +			ctrl_cfg->entity = entity;
> +
> +			return 1;
> +		}
> +
> +		queryctrl.id = queryctrl.id | V4L2_CTRL_FLAG_NEXT_COMPOUND;
> +	}
> +
> +	return 0;
> +}
> +
> +static int validate_control_config(struct media_device *mdev,
> +				struct libv4l_media_ctrl_conf *ctrl_cfg)
> +{
> +	if (mdev == NULL || ctrl_cfg == NULL)
> +		return -EINVAL;
> +
> +	while (ctrl_cfg) {
> +		if (!is_control_supported(mdev, ctrl_cfg)) {
> +			V4L2_EXYNOS4_ERR("Control %s is unsupported on %s.",
> +					 ctrl_cfg->control_name,
> +					 ctrl_cfg->entity_name);
> +			return -EINVAL;
> +		}
> +
> +		ctrl_cfg = ctrl_cfg->next;
> +	}
> +
> +	return 0;
> +}
> +
> +static int get_entity_by_fd(struct media_device *mdev, int fd,
> +				struct media_entity **entity)
> +{
> +	char node_name[32];
> +	int i, ret;
> +
> +	if (mdev == NULL || entity == NULL)
> +		return -EINVAL;
> +
> +	ret = get_node_by_fd(fd, node_name);
> +	if (ret < 0)
> +		return ret;
> +
> +	for (i = 0; i < mdev->num_entities; ++i) {
> +		if (strcmp(mdev->entities[i].node_name, node_name) == 0) {
> +			*entity = &mdev->entities[i];
> +			return 0;
> +		}
> +	}
> +
> +	return -EINVAL;
> +}
> +
> +static int get_pads_by_entity(struct media_entity *entity,
> +				struct media_pad_desc **pads,
> +				int *num_pads, unsigned int type)
> +{
> +	struct media_pad_desc *entity_pads;
> +	int cnt_pads, i;
> +
> +	if (entity == NULL || pads == NULL || num_pads == NULL)
> +		return -EINVAL;
> +
> +	entity_pads = malloc(sizeof(*entity_pads));
> +	cnt_pads = 0;
> +
> +	for (i = 0; i < entity->num_pads; ++i) {
> +		if (entity->pads[i].flags & type) {
> +			entity_pads = realloc(entity_pads, (i + 1) *
> +					      sizeof(*entity_pads));
> +			entity_pads[cnt_pads++] = entity->pads[i];
> +		}
> +	}
> +
> +	if (cnt_pads == 0)
> +		free(entity_pads);
> +
> +	*pads = entity_pads;
> +	*num_pads = cnt_pads;
> +
> +	return 0;
> +}
> +
> +static int get_src_entity_by_link(struct media_device *mdev,
> +					struct media_link_desc *link,
> +					struct media_entity **entity)
> +{
> +	int i;
> +
> +	if (mdev == NULL || link == NULL || entity == NULL)
> +		return -EINVAL;
> +
> +	for (i = 0; i < mdev->num_entities; ++i) {
> +		if (mdev->entities[i].id == link->source.entity) {
> +			*entity = &mdev->entities[i];
> +			return 0;
> +		}
> +	}
> +
> +	return -EINVAL;
> +}
> +
> +static int get_link_by_sink_pad(struct media_device *mdev,
> +				struct media_pad_desc *pad,
> +				struct media_link_desc **link)
> +{
> +	struct media_link_desc *cur_link = NULL;
> +	struct media_entity *entity;
> +	int i, j, ret;
> +
> +	if (mdev == NULL || pad == NULL || link == NULL)
> +		return -EINVAL;
> +
> +	ret = get_entity_by_pad(mdev, pad, &entity);
> +	if (ret < 0)
> +		return ret;
> +
> +	for (i = 0; i < mdev->num_entities; ++i) {
> +		for (j = 0; j < mdev->entities[i].num_links; ++j) {
> +			cur_link = &mdev->entities[i].links[j];
> +			if ((cur_link->flags & MEDIA_LNK_FL_ENABLED) &&
> +			    (cur_link->sink.entity == pad->entity) &&
> +			    (cur_link->sink.index == pad->index)) {
> +				*link = cur_link;
> +				return 0;
> +			}
> +		}
> +	}
> +
> +	return -EINVAL;
> +}
> +
> +static int get_link_by_source_pad(struct media_entity *entity,
> +					struct media_pad_desc *pad,
> +					struct media_link_desc **link)
> +{
> +	int i;
> +
> +	if (entity == NULL || pad == NULL || link == NULL)
> +		return -EINVAL;
> +
> +	for (i = 0; i < entity->num_links; ++i) {
> +		if ((entity->links[i].flags & MEDIA_LNK_FL_ENABLED) &&
> +		    (entity->links[i].source.index == pad->index)) {
> +			*link = &entity->links[i];
> +			return 0;
> +		}
> +	}
> +
> +	return -EINVAL;
> +}
> +
> +static int get_busy_pads_by_entity(struct media_device *mdev,
> +		       struct media_entity *entity,
> +		       struct media_pad_desc **busy_pads,
> +		       int *num_busy_pads,
> +		       unsigned int type)
> +{
> +	struct media_pad_desc *bpads, *pads;
> +	struct media_link_desc *link;
> +	int cnt_bpads = 0, num_pads, i, ret;
> +
> +	if (entity == NULL || busy_pads == NULL || num_busy_pads == NULL ||
> +	    (type == MEDIA_PAD_FL_SINK && mdev == NULL))
> +		return -EINVAL;
> +
> +	ret = get_pads_by_entity(entity, &pads, &num_pads, type);
> +	if (ret < 0)
> +		return -EINVAL;
> +
> +	if (num_pads == 0)
> +		goto done;
> +
> +	bpads = malloc(sizeof(*pads));
> +	if (bpads == NULL)
> +		goto error_ret;
> +
> +	for (i = 0; i < num_pads; ++i) {
> +		if (type == MEDIA_PAD_FL_SINK)
> +			ret = get_link_by_sink_pad(mdev, &pads[i], &link);
> +		else
> +			ret = get_link_by_source_pad(entity, &pads[i], &link);
> +		if (ret == 0) {
> +			bpads = realloc(bpads, (i + 1) *
> +						sizeof(*bpads));
> +			bpads[cnt_bpads++] = pads[i];
> +		}
> +	}
> +	if (num_pads > 0)
> +		free(pads);
> +
> +	if (cnt_bpads == 0)
> +		free(bpads);
> +
> +done:
> +	*busy_pads = bpads;
> +	*num_busy_pads = cnt_bpads;
> +
> +	return 0;
> +
> +error_ret:
> +	return -EINVAL;
> +}
> +
> +static int get_pad_by_index(struct media_pad_desc *pads, int num_pads,
> +				int index, struct media_pad_desc *out_pad)
> +
> +{
> +	int i;
> +
> +	if (pads == NULL || out_pad == NULL)
> +		return -EINVAL;
> +
> +	for (i = 0; i < num_pads; ++i) {
> +		if (pads[i].index == index) {
> +			*out_pad = pads[i];
> +			return 0;
> +		}
> +	}
> +
> +	return -EINVAL;
> +}
> +
> +static int discover_pipeline_by_fd(struct media_device *mdev, int fd)
> +{
> +	struct media_entity *entity, *pipe_head = NULL;
> +	struct media_pad_desc *sink_pads, sink_pad;
> +	struct media_link_desc *link;
> +	int num_sink_pads, prev_link_src_pad = -1, ret;
> +
> +	if (mdev == NULL)
> +		return -EINVAL;
> +
> +	/* get sink pipeline entity */
> +	ret = get_entity_by_fd(mdev, fd, &entity);
> +	if (ret < 0)
> +		return ret;
> +
> +	if (entity == NULL)
> +		return -EINVAL;
> +
> +	entity->fd = fd;
> +
> +	for (;;) {
> +		if (pipe_head == NULL) {
> +			pipe_head = entity;
> +		} else {
> +			entity->next = pipe_head;
> +			pipe_head = entity;
> +		}
> +
> +		entity->src_pad_id = prev_link_src_pad;
> +		ret = get_busy_pads_by_entity(mdev, entity,
> +					     &sink_pads,
> +					     &num_sink_pads,
> +					     MEDIA_PAD_FL_SINK);
> +		if (ret < 0)
> +			return ret;
> +
> +		/* check if pipeline source entity has been reached */
> +		if (num_sink_pads > 1) {
> +			/* Case for two parallel active links */
> +			ret = get_pad_by_index(sink_pads, num_sink_pads, 0,
> +							&sink_pad);
> +			if (ret < 0)
> +				return ret;
> +		} else if (num_sink_pads == 1) {
> +			sink_pad = sink_pads[0];
> +		} else {
> +			break;
> +		}
> +		if (num_sink_pads > 0)
> +			free(sink_pads);
> +
> +		ret = get_link_by_sink_pad(mdev, &sink_pad,
> +						   &link);
> +
> +		prev_link_src_pad = link->source.index;
> +		entity->sink_pad_id = link->sink.index;
> +
> +		ret = get_src_entity_by_link(mdev, link, &entity);
> +		if (ret || entity == NULL)
> +			return ret;
> +
> +	}
> +
> +	mdev->pipeline = pipe_head;
> +
> +	return 0;
> +}
> +
> +static int close_pipeline_subdevs(struct media_entity *pipeline)
> +{
> +	if (pipeline == NULL)
> +		return -EINVAL;
> +
> +	while (pipeline) {
> +		close(pipeline->fd);
> +		pipeline = pipeline->next;
> +		if (pipeline->next == NULL)
> +			break;
> +	}
> +
> +	return 0;
> +}
> +
> +static int open_pipeline_subdevs(struct media_entity *pipeline)
> +{
> +	struct media_entity *entity = pipeline;
> +
> +	if (pipeline == NULL)
> +		return -EINVAL;
> +
> +	while (entity) {
> +		entity->fd = open(entity->node_name, O_RDWR);
> +		if (entity->fd < 0) {
> +			V4L2_EXYNOS4_DBG("Could not open device %s",
> +			    entity->node_name);
> +			goto err_open_subdev;
> +		}
> +
> +		entity = entity->next;
> +		if (entity->next == NULL)
> +			break;
> +	}
> +
> +	return 0;
> +
> +err_open_subdev:
> +	while (pipeline) {
> +		if (pipeline == entity)
> +			break;
> +		close(pipeline->fd);
> +		pipeline = pipeline->next;
> +		if (pipeline->next == NULL)
> +			break;
> +	}
> +
> +	return -EINVAL;
> +}
> +
> +static int verify_format(struct v4l2_mbus_framefmt *fmt1,
> +				struct v4l2_mbus_framefmt *fmt2)
> +{
> +	if (fmt1 == NULL || fmt2 == NULL)
> +		return 0;
> +
> +	if (fmt1->width != fmt2->width) {
> +		V4L2_EXYNOS4_DBG("width mismatch")
> +		return 0;
> +	}
> +
> +	if (fmt1->height != fmt2->height) {
> +		V4L2_EXYNOS4_DBG("height mismatch")
> +		return 0;
> +	}
> +
> +	if (fmt1->code != fmt2->code) {
> +		V4L2_EXYNOS4_DBG("code mismatch")
> +		return 0;
> +	}
> +
> +	if (fmt1->field != fmt2->field) {
> +		V4L2_EXYNOS4_DBG("field mismatch")
> +		return 0;
> +	}
> +
> +	if (fmt1->colorspace != fmt2->colorspace) {
> +		V4L2_EXYNOS4_DBG("colorspace mismatch")
> +		return 0;
> +	}
> +
> +	return 1;
> +}
> +
> +static int get_format_name(__u32 pix_code, int *fmt_id)
> +{
> +	int i;
> +
> +	if (fmt_id == NULL)
> +		return -EINVAL;
> +
> +	for (i = 0; i < ARRAY_SIZE(mbus_codes); ++i) {
> +		if (mbus_codes[i].code == pix_code) {
> +			*fmt_id = i;
> +			return 0;
> +		}
> +	}
> +
> +	return -EINVAL;
> +}
> +
> +static int rgb_fmt(unsigned int pix_fmt)
> +{
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(rgb_px_fmt); ++i) {
> +		if (rgb_px_fmt[i] == pix_fmt)
> +			return 1;
> +	}
> +
> +	return 0;
> +}
> +
> +static int yuv_fmt(unsigned int pix_fmt)
> +{
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(yuv_px_fmt); ++i) {
> +		if (yuv_px_fmt[i] == pix_fmt)
> +			return 1;
> +	}
> +
> +	return 0;
> +}
> +
> +static int jpeg_fmt(unsigned int pix_fmt)
> +{
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(jpeg_px_fmt); ++i) {
> +		if (jpeg_px_fmt[i] == pix_fmt)
> +			return 1;
> +	}
> +
> +	return 0;
> +}
> +
> +static int sensor_fmt(unsigned int pix_fmt)
> +{
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(sensor_px_fmt); ++i) {
> +		if (sensor_px_fmt[i] == pix_fmt)
> +			return 1;
> +	}
> +
> +	return 0;
> +}
> +
> +static int select_mbus_codes_by_pix_fmt(unsigned int pix_fmt)
> +{
> +	int fmt_flags, i;
> +
> +	if (rgb_fmt(pix_fmt) || yuv_fmt(pix_fmt))
> +		fmt_flags = RGB_PX_FMT | YUV_PX_FMT;
> +	else if (jpeg_fmt(pix_fmt))
> +		fmt_flags = JPEG_PX_FMT;
> +	else if (sensor_fmt(pix_fmt))
> +		fmt_flags = SENSOR_PX_FMT;
> +	else
> +		return -EINVAL;
> +
> +	for (i = 0; i < ARRAY_SIZE(mbus_codes); ++i)
> +		mbus_codes[i].supported = !!(mbus_codes[i].compat_pix_fmts
> +					   & fmt_flags);
> +
> +	return 0;
> +}
> +
> +static int enumerate_subdev_mbus_codes(struct media_entity *entity,
> +			    int pad_id,
> +			    struct v4l2_subdev_mbus_code_enum **fmt_enum,
> +			    int *num_codes)
> +{
> +	struct v4l2_subdev_mbus_code_enum *temp_fmt_enum;
> +	int i, code_id, ret;
> +
> +	if (entity == NULL || fmt_enum == NULL || num_codes == NULL)
> +		return -EINVAL;
> +
> +	temp_fmt_enum = malloc(sizeof(*temp_fmt_enum));
> +
> +	for (i = 0;; ++i) {
> +		temp_fmt_enum = realloc(temp_fmt_enum, (i + 1) *
> +						sizeof(*temp_fmt_enum));
> +		if (temp_fmt_enum == NULL)
> +			goto err_enum_subdev;
> +
> +		memset(&temp_fmt_enum[i], 0, sizeof(*temp_fmt_enum));
> +		temp_fmt_enum[i].pad = pad_id;
> +		temp_fmt_enum[i].index = i;
> +
> +		ret = SYS_IOCTL(entity->fd,
> +			    VIDIOC_SUBDEV_ENUM_MBUS_CODE, &temp_fmt_enum[i]);
> +		if (ret < 0)
> +			break;
> +
> +		ret = get_format_name(temp_fmt_enum[i].code, &code_id);
> +		if (ret < 0)
> +			goto err_enum_subdev;
> +
> +		V4L2_EXYNOS4_DBG("name: %s, pad: %d, format: %s, fmt_id: %x",
> +		    entity->name,
> +		    temp_fmt_enum[i].pad,
> +		    mbus_codes[code_id].name, temp_fmt_enum[i].code);
> +	}
> +
> +	*fmt_enum = temp_fmt_enum;
> +	*num_codes = i + 1;
> +
> +	return 0;
> +
> +err_enum_subdev:
> +	free(temp_fmt_enum);
> +
> +	return -EINVAL;
> +}
> +
> +static int mark_unsupported_mbus_codes(
> +				struct v4l2_subdev_mbus_code_enum *subdev_codes,
> +				int num_subdev_codes)
> +{
> +	int i, j;
> +
> +	if (subdev_codes == NULL)
> +		return -EINVAL;
> +
> +	/*
> +	 * Mark mbus codes not present in the passed subdev_codes
> +	 * array as unsupported, to prevent them from being selected
> +	 * as the common mbus code for the whole pipeline.
> +	 */
> +	for (i = 0; i < ARRAY_SIZE(mbus_codes); ++i) {
> +		for (j = 0; j < num_subdev_codes; ++j) {
> +			if (mbus_codes[i].code == subdev_codes[j].code)
> +				break;
> +		}
> +		/* Don't take into account mbus codes once marked unsupported */
> +		if (mbus_codes[i].supported)
> +			mbus_codes[i].supported = (j != num_subdev_codes);
> +	}
> +
> +	return 0;
> +}
> +
> +static int negotiate_mbus_pix_code(struct media_device *mdev,
> +					unsigned int pix_fmt,
> +					struct mbus_code_meta_pkg *mbus_code)
> +{
> +	struct v4l2_subdev_mbus_code_enum *subdev_mbus_codes = NULL;
> +	struct media_entity *entity;
> +	int i, num_subdev_codes, ret;
> +
> +	if (mdev == NULL || mbus_code == NULL)
> +		return -EINVAL;
> +
> +	entity = mdev->pipeline;
> +
> +	ret = select_mbus_codes_by_pix_fmt(pix_fmt);
> +	if (ret < 0)
> +		goto err_neg_mbus_code;
> +
> +	while (entity) {
> +		ret = enumerate_subdev_mbus_codes(entity,
> +						  entity->src_pad_id,
> +						  &subdev_mbus_codes,
> +						  &num_subdev_codes);
> +		if (ret < 0)
> +			return ret;
> +
> +		ret = mark_unsupported_mbus_codes(subdev_mbus_codes,
> +						  num_subdev_codes);
> +		if (ret < 0)
> +			goto err_neg_mbus_code;
> +
> +		free(subdev_mbus_codes);
> +
> +		/* Negotiation should stop on FIMC-IS-ISP entity */
> +		if (strcmp(entity->name, EXYNOS4_FIMC_IS_ISP) == 0)
> +			break;
> +
> +		entity = entity->next;
> +		/*
> +		 * We should exit the loop if current entity
> +		 * is pipeline's sink, as it is not a subdev.
> +		 */
> +		if (entity->next == NULL)
> +			break;
> +	}
> +
> +	for (i = 0; i < ARRAY_SIZE(mbus_codes); ++i) {
> +		if (mbus_codes[i].supported) {
> +			*mbus_code = mbus_codes[i];
> +			return 0;
> +		}
> +	}
> +
> +	return -EINVAL;
> +
> +err_neg_mbus_code:
> +	free(subdev_mbus_codes);
> +
> +	return -EINVAL;
> +}
> +
> +static int has_pipeline_entity(struct media_entity *pipeline, char *entity)
> +{
> +	if (pipeline == NULL || entity == NULL)
> +		return -EINVAL;
> +
> +	while (pipeline) {
> +		if (!strcmp(pipeline->name, entity))
> +			return 1;
> +		pipeline = pipeline->next;
> +	}
> +
> +	return 0;
> +}
> +
> +static int adjust_format_to_fimc_is_isp(struct v4l2_mbus_framefmt *mbus_fmt)
> +{
> +	if (mbus_fmt == NULL)
> +		return -EINVAL;
> +
> +	mbus_fmt->width += 16;
> +	mbus_fmt->height += 12;
> +
> +	return 0;
> +}
> +
> +static int negotiate_pipeline_fmt(struct media_device *mdev,
> +		       struct v4l2_format *dev_fmt,
> +		       struct mbus_code_meta_pkg *mbus_code)
> +{
> +	struct media_entity *vid_pipe;
> +	struct v4l2_subdev_format subdev_fmt = { 0 };
> +	struct v4l2_mbus_framefmt mbus_fmt = { 0 }, common_fmt;
> +	int repeat_negotiation, cnt_negotiation = 0, ret;
> +
> +	if (mdev == NULL || dev_fmt == NULL || mbus_code == NULL)
> +		return -EINVAL;
> +
> +	ret = select_mbus_codes_by_pix_fmt(dev_fmt->fmt.pix_mp.pixelformat);
> +	if (ret < 0)
> +		return ret;
> +
> +	vid_pipe = mdev->pipeline;
> +
> +	mbus_fmt.width = dev_fmt->fmt.pix_mp.width;
> +	mbus_fmt.height = dev_fmt->fmt.pix_mp.height;
> +	mbus_fmt.field = dev_fmt->fmt.pix_mp.field;
> +	mbus_fmt.colorspace = dev_fmt->fmt.pix_mp.colorspace;
> +
> +	subdev_fmt.which = V4L2_SUBDEV_FORMAT_TRY;
> +
> +	if (has_pipeline_entity(vid_pipe, EXYNOS4_FIMC_IS_ISP)) {
> +		ret = adjust_format_to_fimc_is_isp(&mbus_fmt);
> +		if (ret < 0)
> +			return ret;
> +	}
> +
> +	subdev_fmt.format = mbus_fmt;
> +
> +	for (;;) {
> +		repeat_negotiation = 0;
> +		vid_pipe = mdev->pipeline;
> +
> +		subdev_fmt.pad = vid_pipe->src_pad_id;
> +
> +		ret = SYS_IOCTL(vid_pipe->fd, VIDIOC_SUBDEV_S_FMT,
> +			    &subdev_fmt);
> +		if (ret < 0)
> +			return ret;
> +
> +		common_fmt = subdev_fmt.format;
> +		vid_pipe->subdev_fmt = subdev_fmt;
> +
> +		vid_pipe = mdev->pipeline->next;
> +
> +		while (vid_pipe) {
> +			subdev_fmt.pad = vid_pipe->sink_pad_id;
> +
> +			/* Set format on the entity src pad */
> +			ret =
> +			    SYS_IOCTL(vid_pipe->fd, VIDIOC_SUBDEV_S_FMT,
> +				  &subdev_fmt);
> +			if (ret < 0)
> +				return ret;
> +
> +			if (!verify_format(&subdev_fmt.format, &common_fmt)) {
> +				repeat_negotiation = 1;
> +				break;
> +			}
> +
> +			vid_pipe->subdev_fmt = subdev_fmt;
> +
> +			/*
> +			 * Do not check format on FIMC.[n] source pad
> +			 * and stop negotiation.
> +			 */
> +			if (!strncmp(vid_pipe->name,
> +					EXYNOS4_FIMC_PREFIX,
> +					strlen(EXYNOS4_FIMC_PREFIX)))
> +				break;
> +
> +			subdev_fmt.pad = vid_pipe->src_pad_id;
> +
> +			/* Get format on the entity sink pad */
> +			ret =
> +			    SYS_IOCTL(vid_pipe->fd, VIDIOC_SUBDEV_G_FMT,
> +				  &subdev_fmt);
> +			if (ret < 0)
> +				return -EINVAL;
> +
> +			if (!strcmp(vid_pipe->name,
> +						EXYNOS4_FIMC_IS_ISP)) {
> +				common_fmt.code = subdev_fmt.format.code;
> +				common_fmt.colorspace =
> +						subdev_fmt.format.colorspace;
> +				common_fmt.width -= 16;
> +				common_fmt.height -= 12;
> +			}
> +			/* Bring back source pad id to the subdev format */
> +			subdev_fmt.pad = vid_pipe->sink_pad_id;
> +
> +			if (!verify_format(&subdev_fmt.format, &common_fmt)) {
> +				repeat_negotiation = 1;
> +				break;
> +			}
> +
> +			vid_pipe = vid_pipe->next;
> +			if (vid_pipe->next == NULL)
> +				break;
> +		}
> +
> +		if (!repeat_negotiation) {
> +			break;
> +		} else if (++cnt_negotiation > MAX_FMT_NEGO_NUM) {
> +			V4L2_EXYNOS4_DBG("Pipeline format negotiation failed!");
> +			return -EINVAL;
> +		}
> +	}
> +
> +	dev_fmt->fmt.pix_mp.width = subdev_fmt.format.width;
> +	dev_fmt->fmt.pix_mp.height = subdev_fmt.format.height;
> +	dev_fmt->fmt.pix_mp.field = subdev_fmt.format.field;
> +	dev_fmt->fmt.pix_mp.colorspace = subdev_fmt.format.colorspace;
> +
> +	return 0;
> +}
> +
> +static int try_set_subdev_fmt(struct media_device *mdev,
> +		   struct v4l2_format *dev_fmt,
> +		   struct mbus_code_meta_pkg *mbus_code)
> +{
> +	int ret;
> +
> +	if (mdev == NULL || dev_fmt == NULL || mbus_code == NULL)
> +		return -EINVAL;
> +
> +	ret = negotiate_mbus_pix_code(mdev,
> +				      dev_fmt->fmt.pix_mp.pixelformat,
> +				      mbus_code);
> +	if (ret < 0)
> +		return ret;
> +
> +	V4L2_EXYNOS4_DBG("Negotiated mbus code: %s", mbus_code->name);
> +
> +	ret = negotiate_pipeline_fmt(mdev, dev_fmt, mbus_code);
> +	if (ret < 0)
> +		return ret;
> +
> +	return 0;
> +}
> +
> +static int set_subdev_fmt(struct media_entity *pipeline,
> +				struct v4l2_format *dev_fmt,
> +				struct mbus_code_meta_pkg *mbus_code)
> +{
> +	struct v4l2_subdev_format subdev_fmt = { 0 };
> +	int ret;
> +
> +	if (pipeline == NULL || dev_fmt == NULL || mbus_code == NULL)
> +		return -EINVAL;
> +
> +	while (pipeline) {
> +		subdev_fmt = pipeline->subdev_fmt;
> +		subdev_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
> +		ret = SYS_IOCTL(pipeline->fd, VIDIOC_SUBDEV_S_FMT,
> +			    &subdev_fmt);
> +		if (ret < 0)
> +			return ret;
> +
> +		pipeline = pipeline->next;
> +		if (pipeline->next == NULL)
> +			break;
> +	}
> +
> +	/* seek for pipeline sink entity */
> +	while (pipeline->next)
> +		pipeline = pipeline->next;
> +
> +	ret = SYS_IOCTL(pipeline->fd, VIDIOC_S_FMT, dev_fmt);
> +	if (ret < 0)
> +		return ret;
> +
> +	return 0;
> +}
> +
> +static int convert_type(int type)
> +{
> +	switch (type) {
> +	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
> +		return V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
> +	default:
> +		return type;
> +	}
> +}
> +
> +static int set_fmt_ioctl(struct exynos4_camera_plugin *plugin,
> +			 unsigned long int cmd,
> +			 struct v4l2_format *arg,
> +			 enum v4l2_subdev_format_whence set_mode)
> +{
> +	struct v4l2_format fmt = { 0 };
> +	struct v4l2_format *org = arg;
> +	struct mbus_code_meta_pkg mbus_code = { 0 };
> +	int ret;
> +
> +	if (plugin == NULL || arg == NULL)
> +		return -EINVAL;
> +
> +	fmt.type = convert_type(arg->type);
> +	if (fmt.type != arg->type) {
> +		fmt.fmt.pix_mp.width = org->fmt.pix.width;
> +		fmt.fmt.pix_mp.height = org->fmt.pix.height;
> +		fmt.fmt.pix_mp.pixelformat = org->fmt.pix.pixelformat;
> +		fmt.fmt.pix_mp.field = org->fmt.pix.field;
> +		fmt.fmt.pix_mp.colorspace = org->fmt.pix.colorspace;
> +		fmt.fmt.pix_mp.num_planes = 1;
> +		fmt.fmt.pix_mp.plane_fmt[0].bytesperline =
> +						org->fmt.pix.bytesperline;
> +		fmt.fmt.pix_mp.plane_fmt[0].sizeimage = org->fmt.pix.sizeimage;
> +	} else {
> +		fmt = *org;
> +	}
> +
> +	ret = try_set_subdev_fmt(&plugin->mdev, &fmt, &mbus_code);
> +	if (ret < 0)
> +		return ret;
> +
> +	if (set_mode == V4L2_SUBDEV_FORMAT_ACTIVE) {
> +		ret = set_subdev_fmt(plugin->mdev.pipeline, &fmt, &mbus_code);
> +		if (ret < 0)
> +			return ret;
> +	}
> +
> +	if (fmt.type != arg->type) {
> +		org->fmt.pix.width = fmt.fmt.pix_mp.width;
> +		org->fmt.pix.height = fmt.fmt.pix_mp.height;
> +		org->fmt.pix.pixelformat = fmt.fmt.pix_mp.pixelformat;
> +		org->fmt.pix.field = fmt.fmt.pix_mp.field;
> +		org->fmt.pix.colorspace = fmt.fmt.pix_mp.colorspace;
> +		org->fmt.pix.bytesperline =
> +				fmt.fmt.pix_mp.plane_fmt[0].bytesperline;
> +		org->fmt.pix.sizeimage = fmt.fmt.pix_mp.plane_fmt[0].sizeimage;
> +	} else {
> +		*org = fmt;
> +	}
> +
> +	return 0;
> +}
> +
> +static int get_fmt_ioctl(struct exynos4_camera_plugin *plugin,
> +			 unsigned long int cmd,
> +			 struct v4l2_format *arg)
> +{
> +	struct v4l2_format fmt = { 0 };
> +	struct v4l2_format *org = arg;
> +	int ret;
> +
> +	if (plugin == NULL || arg == NULL)
> +		return -EINVAL;
> +
> +	fmt.type = convert_type(arg->type);
> +
> +	if (fmt.type == arg->type)
> +		return SYS_IOCTL(plugin->vid_fd, cmd, arg);
> +
> +	ret = SYS_IOCTL(plugin->vid_fd, cmd, &fmt);
> +	if (ret < 0)
> +		return ret;
> +
> +	org->fmt.pix.width = fmt.fmt.pix_mp.width;
> +	org->fmt.pix.height = fmt.fmt.pix_mp.height;
> +	org->fmt.pix.pixelformat = fmt.fmt.pix_mp.pixelformat;
> +	org->fmt.pix.field = fmt.fmt.pix_mp.field;
> +	org->fmt.pix.colorspace = fmt.fmt.pix_mp.colorspace;
> +	org->fmt.pix.bytesperline = fmt.fmt.pix_mp.plane_fmt[0].bytesperline;
> +	org->fmt.pix.sizeimage = fmt.fmt.pix_mp.plane_fmt[0].sizeimage;
> +
> +	/*
> +	 * If the device doesn't support just one plane, there's
> +	 * nothing we can do, except return an error condition.
> +	 */
> +	if (fmt.fmt.pix_mp.num_planes > 1) {
> +		errno = -EINVAL;
> +		return -1;
> +	}
> +
> +	return ret;
> +}
> +
> +static int enum_fmt_ioctl(struct exynos4_camera_plugin *plugin,
> +			  unsigned long int cmd,
> +			  struct v4l2_fmtdesc *arg)
> +{
> +	struct v4l2_fmtdesc efmt = *arg;
> +	struct v4l2_fmtdesc *org = arg;
> +	int ret;
> +
> +	if (plugin == NULL || arg == NULL)
> +		return -EINVAL;
> +
> +	efmt.type = convert_type(arg->type);
> +
> +	if (efmt.type == arg->type)
> +		return SYS_IOCTL(plugin->vid_fd, cmd, arg);
> +
> +	ret = SYS_IOCTL(plugin->vid_fd, cmd, &efmt);
> +	if (ret < 0)
> +		return ret;
> +
> +	efmt.type = org->type;
> +	*org = efmt;
> +
> +	return ret;
> +}
> +
> +static int buf_ioctl(struct exynos4_camera_plugin *plugin,
> +		     unsigned long int cmd,
> +		     struct v4l2_buffer *arg)
> +{
> +	struct v4l2_buffer buf = *arg;
> +	struct v4l2_plane plane = { 0 };
> +	int ret;
> +
> +	buf.type = convert_type(arg->type);
> +
> +	if (buf.type == arg->type)
> +		return SYS_IOCTL(plugin->vid_fd, cmd, arg);
> +
> +	memcpy(&plane.m, &arg->m, sizeof(plane.m));
> +	plane.length = arg->length;
> +	plane.bytesused = arg->bytesused;
> +
> +	buf.m.planes = &plane;
> +	buf.length = 1;
> +
> +	ret = SYS_IOCTL(plugin->vid_fd, cmd, &buf);
> +
> +	arg->index = buf.index;
> +	arg->memory = buf.memory;
> +	arg->flags = buf.flags;
> +	arg->field = buf.field;
> +	arg->timestamp = buf.timestamp;
> +	arg->timecode = buf.timecode;
> +	arg->sequence = buf.sequence;
> +	arg->length = buf.m.planes[0].length;
> +	arg->m.offset = buf.m.planes[0].m.mem_offset;
> +	arg->bytesused = buf.m.planes[0].bytesused;
> +
> +	return ret;
> +}
> +
> +static int querycap_ioctl(struct exynos4_camera_plugin *plugin,
> +			  struct v4l2_capability *arg)
> +{
> +	int ret;
> +
> +	ret = SYS_IOCTL(plugin->vid_fd, VIDIOC_QUERYCAP, arg);
> +
> +	if (arg->capabilities & V4L2_CAP_VIDEO_CAPTURE_MPLANE)
> +		arg->capabilities |= V4L2_CAP_VIDEO_CAPTURE;
> +
> +	return ret;
> +}
> +
> +static int ctrl_ioctl(struct exynos4_camera_plugin *plugin, int request,
> +			struct v4l2_control *arg)
> +{
> +	struct media_entity *pipeline = plugin->mdev.pipeline;
> +	struct v4l2_control ctrl = *arg, gctrl = *arg;
> +	struct v4l2_queryctrl queryctrl;
> +	struct media_entity *entity;
> +	int ret = 0;
> +
> +	if (pipeline == NULL)
> +		return -EINVAL;
> +
> +	/*
> +	 * The control has to be reset to the default value
> +	 * on all of the pipeline entities, prior setting a new
> +	 * value. This is required in cases when the contol config
> +	 * is changed between subsequent calls to VIDIOC_S_CTRL,
> +	 * to avoid the situation when a control is set on more
> +	 * than one sub-device.
> +	 */
> +	if (request == VIDIOC_S_CTRL) {
> +		while (pipeline) {
> +			queryctrl.id = (ctrl.id - 1) | V4L2_CTRL_FLAG_NEXT_CTRL;
> +
> +			ret = SYS_IOCTL(pipeline->fd, VIDIOC_QUERYCTRL,
> +								&queryctrl);
> +			if (ret < 0 || queryctrl.id != ctrl.id) {
> +				pipeline = pipeline->next;
> +				continue;
> +			}
> +
> +			ret = SYS_IOCTL(pipeline->fd, VIDIOC_G_CTRL, &gctrl);
> +			if (ret < 0)
> +				return -EINVAL;
> +
> +			if (gctrl.value != queryctrl.default_value) {
> +				gctrl.value = queryctrl.default_value;
> +				ret = SYS_IOCTL(pipeline->fd,
> +						VIDIOC_S_CTRL, &gctrl);
> +				if (ret < 0)
> +					return -EINVAL;
> +			}
> +
> +			pipeline = pipeline->next;
> +		}
> +	}
> +
> +	entity = get_entity_by_cid(plugin->config.controls, ctrl.id);
> +	if (entity) {
> +		ret = SYS_IOCTL(entity->fd, request, &ctrl);
> +		V4L2_EXYNOS4_DBG("Setting config control %x succeeded on %s\n",
> +				 ctrl.id,
> +				 entity->name);
> +		goto exit;
> +	}
> +
> +	V4L2_EXYNOS4_DBG("No config for control id %x\n", ctrl.id);
> +
> +	/* Walk the pipeline until the request succeeds */
> +	pipeline = plugin->mdev.pipeline;
> +
> +	while (pipeline) {
> +		ret = SYS_IOCTL(pipeline->fd, request, &ctrl);
> +		if (!ret) {
> +			V4L2_EXYNOS4_DBG("Setting control %x succeeded on %s\n",
> +					 ctrl.id,
> +					 pipeline->name);
> +			goto exit;
> +		}
> +
> +		pipeline = pipeline->next;
> +	}
> +
> +exit:
> +	*arg = ctrl;
> +	return ret;
> +}
> +
> +static void *
> +plugin_init(int fd)
> +{
> +	struct v4l2_capability cap;
> +	struct exynos4_camera_plugin plugin, *ret_plugin = NULL;
> +	char *media_entity_name;
> +	struct media_device *mdev = &plugin.mdev;
> +	int ret;
> +
> +	memset(&plugin, 0, sizeof(plugin));
> +
> +	memset(&cap, 0, sizeof(cap));
> +	ret = SYS_IOCTL(fd, VIDIOC_QUERYCAP, &cap);
> +	if (ret < 0) {
> +		V4L2_EXYNOS4_ERR("Failed to query video capabilities.");
> +		return NULL;
> +	}
> +
> +	/* Get media node for the device */
> +	ret = get_media_node(mdev, fd, &media_entity_name);
> +	if (ret < 0)
> +		return NULL;
> +
> +	/* Check if video entity is of capture type */
> +	if (!capture_entity(media_entity_name))

You're leaking mdev->media_fd here.

> +		return NULL;
> +
> +	ret = libv4l_media_conf_read(EXYNOS4_CAPTURE_CONF, &plugin.config);
> +	if (ret < 0)
> +		return NULL;
> +

You're leaking mdev->media_fd here.

> +	ret = setup_config_links(mdev, plugin.config.links);
> +	/* Release links as they will not be used anymore */
> +	libv4l_media_conf_release_links(plugin.config.links);
> +
> +	if (ret < 0) {
> +		V4L2_EXYNOS4_ERR("Video entities linking failed.");
> +		return NULL;

You're leaking mdev->media_fd here.

> +	}
> +
> +	/* refresh device topology data after linking */
> +	release_entities(mdev);
> +
> +	ret = get_device_topology(mdev);
> +
> +	/* close media device fd as it won't be longer required */
> +	close(mdev->media_fd);
> +
> +	if (ret < 0)
> +		goto err_get_dev_topology;
> +
> +	/* discover a pipeline for the capture device */
> +	ret = discover_pipeline_by_fd(mdev, fd);
> +	if (ret < 0)
> +		goto err_discover_pipeline;

There does not seem to be any code here to ensure that this plugin does
not bind to non exonys4 fimc devices. Please fix that.

> +	ret = open_pipeline_subdevs(mdev->pipeline);
> +	if (ret < 0)
> +		goto err_discover_pipeline;
> +
> +
> +	if (plugin.config.controls) {
> +		ret = validate_control_config(mdev,
> +						plugin.config.controls);
> +		if (ret < 0)
> +			goto err_validate_controls;
> +	}
> +
> +	/* Allocate and initialize private data */
> +	ret_plugin = calloc(1, sizeof(*ret_plugin));
> +	if (!ret_plugin)
> +		goto err_validate_controls;
> +
> +	plugin.vid_fd = fd;
> +
> +	*ret_plugin = plugin;
> +	V4L2_EXYNOS4_DBG("Initialized exynos4-camera plugin.");
> +
> +	return ret_plugin;
> +
> +err_validate_controls:
> +	close_pipeline_subdevs(mdev->pipeline);
> +err_discover_pipeline:
> +	release_entities(mdev);
> +err_get_dev_topology:
> +	libv4l_media_conf_release_controls(plugin.config.controls);
> +	return NULL;
> +}
> +
> +static void plugin_close(void *dev_ops_priv)
> +{
> +	struct exynos4_camera_plugin *plugin;
> +	struct media_device *mdev;
> +
> +	if (dev_ops_priv == NULL)
> +		return;
> +
> +	plugin = (struct exynos4_camera_plugin *) dev_ops_priv;
> +	mdev = &plugin->mdev;
> +
> +	close_pipeline_subdevs(mdev->pipeline);
> +	release_entities(mdev);
> +	libv4l_media_conf_release_controls(plugin->config.controls);
> +
> +	free(plugin);
> +}
> +
> +static int plugin_ioctl(void *dev_ops_priv, int fd, unsigned long int cmd,
> +							void *arg)
> +{
> +	struct exynos4_camera_plugin *plugin = dev_ops_priv;
> +
> +	if (plugin == NULL || arg == NULL)
> +		return -EINVAL;
> +
> +	switch (cmd) {
> +	case VIDIOC_S_CTRL:
> +	case VIDIOC_G_CTRL:
> +		return ctrl_ioctl(plugin, VIDIOC_S_CTRL, arg);
> +	case VIDIOC_TRY_FMT:
> +		return set_fmt_ioctl(plugin, VIDIOC_S_FMT, arg,
> +				     V4L2_SUBDEV_FORMAT_TRY);
> +	case VIDIOC_S_FMT:
> +		return set_fmt_ioctl(plugin, VIDIOC_S_FMT, arg,
> +				     V4L2_SUBDEV_FORMAT_ACTIVE);
> +	case VIDIOC_G_FMT:
> +		return get_fmt_ioctl(plugin, VIDIOC_G_FMT, arg);
> +	case VIDIOC_ENUM_FMT:
> +		return enum_fmt_ioctl(plugin, VIDIOC_ENUM_FMT, arg);
> +	case VIDIOC_QUERYCAP:
> +		return querycap_ioctl(plugin, arg);
> +	case VIDIOC_QBUF:
> +	case VIDIOC_DQBUF:
> +	case VIDIOC_QUERYBUF:
> +	case VIDIOC_PREPARE_BUF:
> +		return buf_ioctl(plugin, cmd, arg);
> +	case VIDIOC_REQBUFS:
> +		return SIMPLE_CONVERT_IOCTL(fd, cmd, arg,
> +					    v4l2_requestbuffers);
> +	case VIDIOC_STREAMON:
> +	case VIDIOC_STREAMOFF:
> +		{
> +			int *arg_type = (int *) arg;
> +			int type;
> +
> +			type = convert_type(*arg_type);
> +
> +			if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
> +			    type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
> +				V4L2_EXYNOS4_ERR("Invalid buffer type.");
> +				return -EINVAL;
> +			}
> +
> +			return SYS_IOCTL(fd, cmd, &type);
> +		}
> +
> +	default:
> +		return SYS_IOCTL(fd, cmd, arg);
> +	}
> +}
> +
> +PLUGIN_PUBLIC const struct libv4l_dev_ops libv4l2_plugin = {
> +	.init = &plugin_init,
> +	.close = &plugin_close,
> +	.ioctl = &plugin_ioctl,
> +};
> 

Please note that this is by no means a full review (-ENOTIME), I focussed
on the plugin_init function, to avoid this causing regressions on non
exonys4 camera devices.

Regards,

Hans