[mirror_ubuntu-hirsute-kernel.git] / drivers / media / platform / vimc / vimc-core.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * vimc-core.c Virtual Media Controller Driver
 *
 * Copyright (C) 2015-2017 Helen Koike <helen.fornazier@gmail.com>
 */

#include <linux/component.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <media/media-device.h>
#include <media/v4l2-device.h>

#include "vimc-common.h"

#define VIMC_MDEV_MODEL_NAME "VIMC MDEV"

#define VIMC_ENT_LINK(src, srcpad, sink, sinkpad, link_flags) {	\
	.src_ent = src,						\
	.src_pad = srcpad,					\
	.sink_ent = sink,					\
	.sink_pad = sinkpad,					\
	.flags = link_flags,					\
}

struct vimc_device {
	/* The platform device */
	struct platform_device pdev;

	/* The pipeline configuration */
	const struct vimc_pipeline_config *pipe_cfg;

	/* The Associated media_device parent */
	struct media_device mdev;

	/* Internal v4l2 parent device*/
	struct v4l2_device v4l2_dev;

	/* Subdevices */
	struct platform_device **subdevs;
};

/* Structure which describes individual configuration for each entity */
struct vimc_ent_config {
	const char *name;
	const char *drv;
};

/* Structure which describes links between entities */
struct vimc_ent_link {
	unsigned int src_ent;
	u16 src_pad;
	unsigned int sink_ent;
	u16 sink_pad;
	u32 flags;
};

/* Structure which describes the whole topology */
struct vimc_pipeline_config {
	const struct vimc_ent_config *ents;
	size_t num_ents;
	const struct vimc_ent_link *links;
	size_t num_links;
};

/* --------------------------------------------------------------------------
 * Topology Configuration
 */

static const struct vimc_ent_config ent_config[] = {
	{
		.name = "Sensor A",
		.drv = "vimc-sensor",
	},
	{
		.name = "Sensor B",
		.drv = "vimc-sensor",
	},
	{
		.name = "Debayer A",
		.drv = "vimc-debayer",
	},
	{
		.name = "Debayer B",
		.drv = "vimc-debayer",
	},
	{
		.name = "Raw Capture 0",
		.drv = "vimc-capture",
	},
	{
		.name = "Raw Capture 1",
		.drv = "vimc-capture",
	},
	{
		.name = "RGB/YUV Input",
		/* TODO: change this to vimc-input when it is implemented */
		.drv = "vimc-sensor",
	},
	{
		.name = "Scaler",
		.drv = "vimc-scaler",
	},
	{
		.name = "RGB/YUV Capture",
		.drv = "vimc-capture",
	},
};

static const struct vimc_ent_link ent_links[] = {
	/* Link: Sensor A (Pad 0)->(Pad 0) Debayer A */
	VIMC_ENT_LINK(0, 0, 2, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
	/* Link: Sensor A (Pad 0)->(Pad 0) Raw Capture 0 */
	VIMC_ENT_LINK(0, 0, 4, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
	/* Link: Sensor B (Pad 0)->(Pad 0) Debayer B */
	VIMC_ENT_LINK(1, 0, 3, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
	/* Link: Sensor B (Pad 0)->(Pad 0) Raw Capture 1 */
	VIMC_ENT_LINK(1, 0, 5, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
	/* Link: Debayer A (Pad 1)->(Pad 0) Scaler */
	VIMC_ENT_LINK(2, 1, 7, 0, MEDIA_LNK_FL_ENABLED),
	/* Link: Debayer B (Pad 1)->(Pad 0) Scaler */
	VIMC_ENT_LINK(3, 1, 7, 0, 0),
	/* Link: RGB/YUV Input (Pad 0)->(Pad 0) Scaler */
	VIMC_ENT_LINK(6, 0, 7, 0, 0),
	/* Link: Scaler (Pad 1)->(Pad 0) RGB/YUV Capture */
	VIMC_ENT_LINK(7, 1, 8, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
};

static const struct vimc_pipeline_config pipe_cfg = {
	.ents		= ent_config,
	.num_ents	= ARRAY_SIZE(ent_config),
	.links		= ent_links,
	.num_links	= ARRAY_SIZE(ent_links)
};

/* -------------------------------------------------------------------------- */

static int vimc_create_links(struct vimc_device *vimc)
{
	unsigned int i;
	int ret;

	/* Initialize the links between entities */
	for (i = 0; i < vimc->pipe_cfg->num_links; i++) {
		const struct vimc_ent_link *link = &vimc->pipe_cfg->links[i];
		/*
		 * TODO: Check another way of retrieving ved struct without
		 * relying on platform_get_drvdata
		 */
		struct vimc_ent_device *ved_src =
			platform_get_drvdata(vimc->subdevs[link->src_ent]);
		struct vimc_ent_device *ved_sink =
			platform_get_drvdata(vimc->subdevs[link->sink_ent]);

		ret = media_create_pad_link(ved_src->ent, link->src_pad,
					    ved_sink->ent, link->sink_pad,
					    link->flags);
		if (ret)
			return ret;
	}

	return 0;
}

static int vimc_comp_bind(struct device *master)
{
	struct vimc_device *vimc = container_of(to_platform_device(master),
						struct vimc_device, pdev);
	int ret;

	dev_dbg(master, "bind");

	/* Register the v4l2 struct */
	ret = v4l2_device_register(vimc->mdev.dev, &vimc->v4l2_dev);
	if (ret) {
		dev_err(vimc->mdev.dev,
			"v4l2 device register failed (err=%d)\n", ret);
		return ret;
	}

	/* Bind subdevices */
	ret = component_bind_all(master, &vimc->v4l2_dev);
	if (ret)
		goto err_v4l2_unregister;

	/* Initialize links */
	ret = vimc_create_links(vimc);
	if (ret)
		goto err_comp_unbind_all;

	/* Register the media device */
	ret = media_device_register(&vimc->mdev);
	if (ret) {
		dev_err(vimc->mdev.dev,
			"media device register failed (err=%d)\n", ret);
		goto err_comp_unbind_all;
	}

	/* Expose all subdev's nodes*/
	ret = v4l2_device_register_subdev_nodes(&vimc->v4l2_dev);
	if (ret) {
		dev_err(vimc->mdev.dev,
			"vimc subdev nodes registration failed (err=%d)\n",
			ret);
		goto err_mdev_unregister;
	}

	return 0;

err_mdev_unregister:
	media_device_unregister(&vimc->mdev);
	media_device_cleanup(&vimc->mdev);
err_comp_unbind_all:
	component_unbind_all(master, NULL);
err_v4l2_unregister:
	v4l2_device_unregister(&vimc->v4l2_dev);

	return ret;
}

static void vimc_comp_unbind(struct device *master)
{
	struct vimc_device *vimc = container_of(to_platform_device(master),
						struct vimc_device, pdev);

	dev_dbg(master, "unbind");

	media_device_unregister(&vimc->mdev);
	media_device_cleanup(&vimc->mdev);
	component_unbind_all(master, NULL);
	v4l2_device_unregister(&vimc->v4l2_dev);
}

static int vimc_comp_compare(struct device *comp, void *data)
{
	const struct platform_device *pdev = to_platform_device(comp);
	const char *name = data;

	return !strcmp(pdev->dev.platform_data, name);
}

static struct component_match *vimc_add_subdevs(struct vimc_device *vimc)
{
	struct component_match *match = NULL;
	struct vimc_platform_data pdata;
	int i;

	for (i = 0; i < vimc->pipe_cfg->num_ents; i++) {
		dev_dbg(&vimc->pdev.dev, "new pdev for %s\n",
			vimc->pipe_cfg->ents[i].drv);

		strscpy(pdata.entity_name, vimc->pipe_cfg->ents[i].name,
			sizeof(pdata.entity_name));

		vimc->subdevs[i] = platform_device_register_data(&vimc->pdev.dev,
						vimc->pipe_cfg->ents[i].drv,
						PLATFORM_DEVID_AUTO,
						&pdata,
						sizeof(pdata));
		if (IS_ERR(vimc->subdevs[i])) {
			match = ERR_CAST(vimc->subdevs[i]);
			while (--i >= 0)
				platform_device_unregister(vimc->subdevs[i]);

			return match;
		}

		component_match_add(&vimc->pdev.dev, &match, vimc_comp_compare,
				    (void *)vimc->pipe_cfg->ents[i].name);
	}

	return match;
}

static void vimc_rm_subdevs(struct vimc_device *vimc)
{
	unsigned int i;

	for (i = 0; i < vimc->pipe_cfg->num_ents; i++)
		platform_device_unregister(vimc->subdevs[i]);
}

static const struct component_master_ops vimc_comp_ops = {
	.bind = vimc_comp_bind,
	.unbind = vimc_comp_unbind,
};

static int vimc_probe(struct platform_device *pdev)
{
	struct vimc_device *vimc = container_of(pdev, struct vimc_device, pdev);
	struct component_match *match = NULL;
	int ret;

	dev_dbg(&pdev->dev, "probe");

	memset(&vimc->mdev, 0, sizeof(vimc->mdev));

	/* Create platform_device for each entity in the topology*/
	vimc->subdevs = devm_kcalloc(&vimc->pdev.dev, vimc->pipe_cfg->num_ents,
				     sizeof(*vimc->subdevs), GFP_KERNEL);
	if (!vimc->subdevs)
		return -ENOMEM;

	match = vimc_add_subdevs(vimc);
	if (IS_ERR(match))
		return PTR_ERR(match);

	/* Link the media device within the v4l2_device */
	vimc->v4l2_dev.mdev = &vimc->mdev;

	/* Initialize media device */
	strscpy(vimc->mdev.model, VIMC_MDEV_MODEL_NAME,
		sizeof(vimc->mdev.model));
	snprintf(vimc->mdev.bus_info, sizeof(vimc->mdev.bus_info),
		 "platform:%s", VIMC_PDEV_NAME);
	vimc->mdev.dev = &pdev->dev;
	media_device_init(&vimc->mdev);

	/* Add self to the component system */
	ret = component_master_add_with_match(&pdev->dev, &vimc_comp_ops,
					      match);
	if (ret) {
		media_device_cleanup(&vimc->mdev);
		vimc_rm_subdevs(vimc);
		return ret;
	}

	return 0;
}

static int vimc_remove(struct platform_device *pdev)
{
	struct vimc_device *vimc = container_of(pdev, struct vimc_device, pdev);

	dev_dbg(&pdev->dev, "remove");

	component_master_del(&pdev->dev, &vimc_comp_ops);
	vimc_rm_subdevs(vimc);

	return 0;
}

static void vimc_dev_release(struct device *dev)
{
}

static struct vimc_device vimc_dev = {
	.pipe_cfg = &pipe_cfg,
	.pdev = {
		.name = VIMC_PDEV_NAME,
		.dev.release = vimc_dev_release,
	}
};

static struct platform_driver vimc_pdrv = {
	.probe		= vimc_probe,
	.remove		= vimc_remove,
	.driver		= {
		.name	= VIMC_PDEV_NAME,
	},
};

static int __init vimc_init(void)
{
	int ret;

	ret = platform_device_register(&vimc_dev.pdev);
	if (ret) {
		dev_err(&vimc_dev.pdev.dev,
			"platform device registration failed (err=%d)\n", ret);
		return ret;
	}

	ret = platform_driver_register(&vimc_pdrv);
	if (ret) {
		dev_err(&vimc_dev.pdev.dev,
			"platform driver registration failed (err=%d)\n", ret);
		platform_driver_unregister(&vimc_pdrv);
		return ret;
	}

	return 0;
}

static void __exit vimc_exit(void)
{
	platform_driver_unregister(&vimc_pdrv);

	platform_device_unregister(&vimc_dev.pdev);
}

module_init(vimc_init);
module_exit(vimc_exit);

MODULE_DESCRIPTION("Virtual Media Controller Driver (VIMC)");
MODULE_AUTHOR("Helen Fornazier <helen.fornazier@gmail.com>");
MODULE_LICENSE("GPL");
Commit	Line	Data
c942fddf	1	// SPDX-License-Identifier: GPL-2.0-or-later
f2fe8906 HK	2	/*
	3	* vimc-core.c Virtual Media Controller Driver
	4	*
	5	* Copyright (C) 2015-2017 Helen Koike <helen.fornazier@gmail.com>
f2fe8906 HK	6	*/
f2fe8906 HK	7
4a29b709	8	#include <linux/component.h>
f2fe8906 HK	9	#include <linux/init.h>
	10	#include <linux/module.h>
	11	#include <linux/platform_device.h>
	12	#include <media/media-device.h>
	13	#include <media/v4l2-device.h>
	14
5ba0ae43	15	#include "vimc-common.h"
f2fe8906	16
f2fe8906 HK	17	#define VIMC_MDEV_MODEL_NAME "VIMC MDEV"
	18
	19	#define VIMC_ENT_LINK(src, srcpad, sink, sinkpad, link_flags) { \
	20	.src_ent = src, \
	21	.src_pad = srcpad, \
	22	.sink_ent = sink, \
	23	.sink_pad = sinkpad, \
	24	.flags = link_flags, \
	25	}
	26
	27	struct vimc_device {
4a29b709 HF	28	/* The platform device */
	29	struct platform_device pdev;
	30
	31	/* The pipeline configuration */
f2fe8906 HK	32	const struct vimc_pipeline_config *pipe_cfg;
	33
	34	/* The Associated media_device parent */
	35	struct media_device mdev;
	36
	37	/* Internal v4l2 parent device*/
	38	struct v4l2_device v4l2_dev;
	39
4a29b709 HF	40	/* Subdevices */
4a29b709 HF	41	struct platform_device **subdevs;
f2fe8906 HK	42	};
	43
	44	/* Structure which describes individual configuration for each entity */
	45	struct vimc_ent_config {
	46	const char *name;
4a29b709	47	const char *drv;
f2fe8906 HK	48	};
	49
	50	/* Structure which describes links between entities */
	51	struct vimc_ent_link {
	52	unsigned int src_ent;
	53	u16 src_pad;
	54	unsigned int sink_ent;
	55	u16 sink_pad;
	56	u32 flags;
	57	};
	58
	59	/* Structure which describes the whole topology */
	60	struct vimc_pipeline_config {
	61	const struct vimc_ent_config *ents;
	62	size_t num_ents;
	63	const struct vimc_ent_link *links;
	64	size_t num_links;
	65	};
	66
	67	/* --------------------------------------------------------------------------
	68	* Topology Configuration
	69	*/
	70
	71	static const struct vimc_ent_config ent_config[] = {
	72	{
	73	.name = "Sensor A",
4a29b709	74	.drv = "vimc-sensor",
f2fe8906 HK	75	},
	76	{
	77	.name = "Sensor B",
4a29b709	78	.drv = "vimc-sensor",
f2fe8906 HK	79	},
	80	{
	81	.name = "Debayer A",
4a29b709	82	.drv = "vimc-debayer",
f2fe8906 HK	83	},
	84	{
	85	.name = "Debayer B",
4a29b709	86	.drv = "vimc-debayer",
f2fe8906 HK	87	},
	88	{
	89	.name = "Raw Capture 0",
4a29b709	90	.drv = "vimc-capture",
f2fe8906 HK	91	},
	92	{
	93	.name = "Raw Capture 1",
4a29b709	94	.drv = "vimc-capture",
f2fe8906 HK	95	},
	96	{
	97	.name = "RGB/YUV Input",
4a29b709 HF	98	/* TODO: change this to vimc-input when it is implemented */
4a29b709 HF	99	.drv = "vimc-sensor",
f2fe8906 HK	100	},
	101	{
	102	.name = "Scaler",
4a29b709	103	.drv = "vimc-scaler",
f2fe8906 HK	104	},
	105	{
	106	.name = "RGB/YUV Capture",
4a29b709	107	.drv = "vimc-capture",
f2fe8906 HK	108	},
	109	};
	110
	111	static const struct vimc_ent_link ent_links[] = {
	112	/* Link: Sensor A (Pad 0)->(Pad 0) Debayer A */
	113	VIMC_ENT_LINK(0, 0, 2, 0, MEDIA_LNK_FL_ENABLED \| MEDIA_LNK_FL_IMMUTABLE),
	114	/* Link: Sensor A (Pad 0)->(Pad 0) Raw Capture 0 */
	115	VIMC_ENT_LINK(0, 0, 4, 0, MEDIA_LNK_FL_ENABLED \| MEDIA_LNK_FL_IMMUTABLE),
	116	/* Link: Sensor B (Pad 0)->(Pad 0) Debayer B */
	117	VIMC_ENT_LINK(1, 0, 3, 0, MEDIA_LNK_FL_ENABLED \| MEDIA_LNK_FL_IMMUTABLE),
	118	/* Link: Sensor B (Pad 0)->(Pad 0) Raw Capture 1 */
	119	VIMC_ENT_LINK(1, 0, 5, 0, MEDIA_LNK_FL_ENABLED \| MEDIA_LNK_FL_IMMUTABLE),
	120	/* Link: Debayer A (Pad 1)->(Pad 0) Scaler */
	121	VIMC_ENT_LINK(2, 1, 7, 0, MEDIA_LNK_FL_ENABLED),
	122	/* Link: Debayer B (Pad 1)->(Pad 0) Scaler */
	123	VIMC_ENT_LINK(3, 1, 7, 0, 0),
	124	/* Link: RGB/YUV Input (Pad 0)->(Pad 0) Scaler */
	125	VIMC_ENT_LINK(6, 0, 7, 0, 0),
	126	/* Link: Scaler (Pad 1)->(Pad 0) RGB/YUV Capture */
	127	VIMC_ENT_LINK(7, 1, 8, 0, MEDIA_LNK_FL_ENABLED \| MEDIA_LNK_FL_IMMUTABLE),
	128	};
	129
	130	static const struct vimc_pipeline_config pipe_cfg = {
	131	.ents = ent_config,
	132	.num_ents = ARRAY_SIZE(ent_config),
	133	.links = ent_links,
	134	.num_links = ARRAY_SIZE(ent_links)
	135	};
	136
	137	/* -------------------------------------------------------------------------- */
	138
4a29b709	139	static int vimc_create_links(struct vimc_device *vimc)
f2fe8906 HK	140	{
f2fe8906 HK	141	unsigned int i;
f2fe8906 HK	142	int ret;
f2fe8906 HK	143
4a29b709 HF	144	/* Initialize the links between entities */
	145	for (i = 0; i < vimc->pipe_cfg->num_links; i++) {
	146	const struct vimc_ent_link *link = &vimc->pipe_cfg->links[i];
	147	/*
	148	* TODO: Check another way of retrieving ved struct without
	149	* relying on platform_get_drvdata
	150	*/
	151	struct vimc_ent_device *ved_src =
	152	platform_get_drvdata(vimc->subdevs[link->src_ent]);
	153	struct vimc_ent_device *ved_sink =
	154	platform_get_drvdata(vimc->subdevs[link->sink_ent]);
	155
	156	ret = media_create_pad_link(ved_src->ent, link->src_pad,
	157	ved_sink->ent, link->sink_pad,
	158	link->flags);
	159	if (ret)
	160	return ret;
f2fe8906 HK	161	}
f2fe8906 HK	162
4a29b709	163	return 0;
f2fe8906 HK	164	}
f2fe8906 HK	165
4a29b709	166	static int vimc_comp_bind(struct device *master)
f2fe8906	167	{
4a29b709 HF	168	struct vimc_device *vimc = container_of(to_platform_device(master),
4a29b709 HF	169	struct vimc_device, pdev);
f2fe8906 HK	170	int ret;
f2fe8906 HK	171
4a29b709	172	dev_dbg(master, "bind");
f2fe8906 HK	173
	174	/* Register the v4l2 struct */
	175	ret = v4l2_device_register(vimc->mdev.dev, &vimc->v4l2_dev);
	176	if (ret) {
	177	dev_err(vimc->mdev.dev,
	178	"v4l2 device register failed (err=%d)\n", ret);
	179	return ret;
	180	}
	181
4a29b709 HF	182	/* Bind subdevices */
	183	ret = component_bind_all(master, &vimc->v4l2_dev);
	184	if (ret)
	185	goto err_v4l2_unregister;
f2fe8906	186
4a29b709 HF	187	/* Initialize links */
	188	ret = vimc_create_links(vimc);
	189	if (ret)
	190	goto err_comp_unbind_all;
f2fe8906 HK	191
	192	/* Register the media device */
	193	ret = media_device_register(&vimc->mdev);
	194	if (ret) {
	195	dev_err(vimc->mdev.dev,
	196	"media device register failed (err=%d)\n", ret);
4a29b709	197	goto err_comp_unbind_all;
f2fe8906 HK	198	}
	199
	200	/* Expose all subdev's nodes*/
	201	ret = v4l2_device_register_subdev_nodes(&vimc->v4l2_dev);
	202	if (ret) {
	203	dev_err(vimc->mdev.dev,
	204	"vimc subdev nodes registration failed (err=%d)\n",
	205	ret);
4a29b709	206	goto err_mdev_unregister;
f2fe8906 HK	207	}
	208
	209	return 0;
	210
4a29b709 HF	211	err_mdev_unregister:
4a29b709 HF	212	media_device_unregister(&vimc->mdev);
cdabfa84	213	media_device_cleanup(&vimc->mdev);
4a29b709 HF	214	err_comp_unbind_all:
	215	component_unbind_all(master, NULL);
	216	err_v4l2_unregister:
	217	v4l2_device_unregister(&vimc->v4l2_dev);
f2fe8906 HK	218
	219	return ret;
	220	}
	221
4a29b709 HF	222	static void vimc_comp_unbind(struct device *master)
	223	{
	224	struct vimc_device *vimc = container_of(to_platform_device(master),
	225	struct vimc_device, pdev);
	226
	227	dev_dbg(master, "unbind");
	228
	229	media_device_unregister(&vimc->mdev);
cdabfa84	230	media_device_cleanup(&vimc->mdev);
4a29b709 HF	231	component_unbind_all(master, NULL);
	232	v4l2_device_unregister(&vimc->v4l2_dev);
	233	}
	234
	235	static int vimc_comp_compare(struct device comp, void data)
	236	{
	237	const struct platform_device *pdev = to_platform_device(comp);
	238	const char *name = data;
	239
	240	return !strcmp(pdev->dev.platform_data, name);
	241	}
	242
	243	static struct component_match vimc_add_subdevs(struct vimc_device vimc)
	244	{
	245	struct component_match *match = NULL;
	246	struct vimc_platform_data pdata;
	247	int i;
	248
	249	for (i = 0; i < vimc->pipe_cfg->num_ents; i++) {
	250	dev_dbg(&vimc->pdev.dev, "new pdev for %s\n",
	251	vimc->pipe_cfg->ents[i].drv);
	252
c0decac1	253	strscpy(pdata.entity_name, vimc->pipe_cfg->ents[i].name,
4a29b709 HF	254	sizeof(pdata.entity_name));
	255
	256	vimc->subdevs[i] = platform_device_register_data(&vimc->pdev.dev,
	257	vimc->pipe_cfg->ents[i].drv,
	258	PLATFORM_DEVID_AUTO,
	259	&pdata,
	260	sizeof(pdata));
3863360c WY	261	if (IS_ERR(vimc->subdevs[i])) {
3863360c WY	262	match = ERR_CAST(vimc->subdevs[i]);
4a29b709 HF	263	while (--i >= 0)
	264	platform_device_unregister(vimc->subdevs[i]);
	265
3863360c	266	return match;
4a29b709 HF	267	}
	268
	269	component_match_add(&vimc->pdev.dev, &match, vimc_comp_compare,
	270	(void *)vimc->pipe_cfg->ents[i].name);
	271	}
	272
	273	return match;
	274	}
	275
	276	static void vimc_rm_subdevs(struct vimc_device *vimc)
	277	{
	278	unsigned int i;
	279
	280	for (i = 0; i < vimc->pipe_cfg->num_ents; i++)
	281	platform_device_unregister(vimc->subdevs[i]);
	282	}
	283
	284	static const struct component_master_ops vimc_comp_ops = {
	285	.bind = vimc_comp_bind,
	286	.unbind = vimc_comp_unbind,
	287	};
	288
f2fe8906 HK	289	static int vimc_probe(struct platform_device *pdev)
f2fe8906 HK	290	{
4a29b709 HF	291	struct vimc_device *vimc = container_of(pdev, struct vimc_device, pdev);
4a29b709 HF	292	struct component_match *match = NULL;
f2fe8906 HK	293	int ret;
f2fe8906 HK	294
4a29b709	295	dev_dbg(&pdev->dev, "probe");
f2fe8906	296
f74267b5 HV	297	memset(&vimc->mdev, 0, sizeof(vimc->mdev));
f74267b5 HV	298
4a29b709 HF	299	/* Create platform_device for each entity in the topology*/
	300	vimc->subdevs = devm_kcalloc(&vimc->pdev.dev, vimc->pipe_cfg->num_ents,
	301	sizeof(*vimc->subdevs), GFP_KERNEL);
	302	if (!vimc->subdevs)
f2fe8906 HK	303	return -ENOMEM;
f2fe8906 HK	304
4a29b709 HF	305	match = vimc_add_subdevs(vimc);
	306	if (IS_ERR(match))
	307	return PTR_ERR(match);
	308
	309	/* Link the media device within the v4l2_device */
	310	vimc->v4l2_dev.mdev = &vimc->mdev;
f2fe8906 HK	311
f2fe8906 HK	312	/* Initialize media device */
c0decac1	313	strscpy(vimc->mdev.model, VIMC_MDEV_MODEL_NAME,
f2fe8906	314	sizeof(vimc->mdev.model));
6fd369dd HV	315	snprintf(vimc->mdev.bus_info, sizeof(vimc->mdev.bus_info),
6fd369dd HV	316	"platform:%s", VIMC_PDEV_NAME);
f2fe8906 HK	317	vimc->mdev.dev = &pdev->dev;
	318	media_device_init(&vimc->mdev);
	319
4a29b709 HF	320	/* Add self to the component system */
	321	ret = component_master_add_with_match(&pdev->dev, &vimc_comp_ops,
	322	match);
f2fe8906	323	if (ret) {
4a29b709 HF	324	media_device_cleanup(&vimc->mdev);
4a29b709 HF	325	vimc_rm_subdevs(vimc);
f2fe8906 HK	326	return ret;
	327	}
	328
f2fe8906 HK	329	return 0;
	330	}
	331
	332	static int vimc_remove(struct platform_device *pdev)
	333	{
4a29b709	334	struct vimc_device *vimc = container_of(pdev, struct vimc_device, pdev);
f2fe8906	335
4a29b709 HF	336	dev_dbg(&pdev->dev, "remove");
	337
	338	component_master_del(&pdev->dev, &vimc_comp_ops);
	339	vimc_rm_subdevs(vimc);
f2fe8906 HK	340
	341	return 0;
	342	}
	343
	344	static void vimc_dev_release(struct device *dev)
	345	{
	346	}
	347
4a29b709 HF	348	static struct vimc_device vimc_dev = {
	349	.pipe_cfg = &pipe_cfg,
	350	.pdev = {
	351	.name = VIMC_PDEV_NAME,
	352	.dev.release = vimc_dev_release,
	353	}
f2fe8906 HK	354	};
	355
	356	static struct platform_driver vimc_pdrv = {
	357	.probe = vimc_probe,
	358	.remove = vimc_remove,
	359	.driver = {
	360	.name = VIMC_PDEV_NAME,
	361	},
	362	};
	363
	364	static int __init vimc_init(void)
	365	{
	366	int ret;
	367
4a29b709	368	ret = platform_device_register(&vimc_dev.pdev);
f2fe8906	369	if (ret) {
4a29b709	370	dev_err(&vimc_dev.pdev.dev,
f2fe8906 HK	371	"platform device registration failed (err=%d)\n", ret);
	372	return ret;
	373	}
	374
	375	ret = platform_driver_register(&vimc_pdrv);
	376	if (ret) {
4a29b709	377	dev_err(&vimc_dev.pdev.dev,
f2fe8906	378	"platform driver registration failed (err=%d)\n", ret);
4a29b709 HF	379	platform_driver_unregister(&vimc_pdrv);
4a29b709 HF	380	return ret;
f2fe8906 HK	381	}
f2fe8906 HK	382
4a29b709	383	return 0;
f2fe8906 HK	384	}
	385
	386	static void __exit vimc_exit(void)
	387	{
	388	platform_driver_unregister(&vimc_pdrv);
	389
4a29b709	390	platform_device_unregister(&vimc_dev.pdev);
f2fe8906 HK	391	}
	392
	393	module_init(vimc_init);
	394	module_exit(vimc_exit);
	395
	396	MODULE_DESCRIPTION("Virtual Media Controller Driver (VIMC)");
	397	MODULE_AUTHOR("Helen Fornazier <helen.fornazier@gmail.com>");
	398	MODULE_LICENSE("GPL");