[deliverable/linux.git] / drivers / media / platform / vsp1 / vsp1_entity.c

/*
 * vsp1_entity.c  --  R-Car VSP1 Base Entity
 *
 * Copyright (C) 2013 Renesas Corporation
 *
 * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <linux/device.h>
#include <linux/gfp.h>

#include <media/media-entity.h>
#include <media/v4l2-subdev.h>

#include "vsp1.h"
#include "vsp1_entity.h"

/* -----------------------------------------------------------------------------
 * V4L2 Subdevice Operations
 */

struct v4l2_mbus_framefmt *
vsp1_entity_get_pad_format(struct vsp1_entity *entity,
			   struct v4l2_subdev_fh *fh,
			   unsigned int pad, u32 which)
{
	switch (which) {
	case V4L2_SUBDEV_FORMAT_TRY:
		return v4l2_subdev_get_try_format(fh, pad);
	case V4L2_SUBDEV_FORMAT_ACTIVE:
		return &entity->formats[pad];
	default:
		return NULL;
	}
}

/*
 * vsp1_entity_init_formats - Initialize formats on all pads
 * @subdev: V4L2 subdevice
 * @fh: V4L2 subdev file handle
 *
 * Initialize all pad formats with default values. If fh is not NULL, try
 * formats are initialized on the file handle. Otherwise active formats are
 * initialized on the device.
 */
void vsp1_entity_init_formats(struct v4l2_subdev *subdev,
			    struct v4l2_subdev_fh *fh)
{
	struct v4l2_subdev_format format;
	unsigned int pad;

	for (pad = 0; pad < subdev->entity.num_pads - 1; ++pad) {
		memset(&format, 0, sizeof(format));

		format.pad = pad;
		format.which = fh ? V4L2_SUBDEV_FORMAT_TRY
			     : V4L2_SUBDEV_FORMAT_ACTIVE;

		v4l2_subdev_call(subdev, pad, set_fmt, fh, &format);
	}
}

static int vsp1_entity_open(struct v4l2_subdev *subdev,
			    struct v4l2_subdev_fh *fh)
{
	vsp1_entity_init_formats(subdev, fh);

	return 0;
}

const struct v4l2_subdev_internal_ops vsp1_subdev_internal_ops = {
	.open = vsp1_entity_open,
};

/* -----------------------------------------------------------------------------
 * Media Operations
 */

static int vsp1_entity_link_setup(struct media_entity *entity,
				  const struct media_pad *local,
				  const struct media_pad *remote, u32 flags)
{
	struct vsp1_entity *source;

	if (!(local->flags & MEDIA_PAD_FL_SOURCE))
		return 0;

	source = container_of(local->entity, struct vsp1_entity, subdev.entity);

	if (!source->route)
		return 0;

	if (flags & MEDIA_LNK_FL_ENABLED) {
		if (source->sink)
			return -EBUSY;
		source->sink = remote->entity;
	} else {
		source->sink = NULL;
	}

	return 0;
}

const struct media_entity_operations vsp1_media_ops = {
	.link_setup = vsp1_entity_link_setup,
	.link_validate = v4l2_subdev_link_validate,
};

/* -----------------------------------------------------------------------------
 * Initialization
 */

int vsp1_entity_init(struct vsp1_device *vsp1, struct vsp1_entity *entity,
		     unsigned int num_pads)
{
	static const struct {
		unsigned int id;
		unsigned int reg;
	} routes[] = {
		{ VI6_DPR_NODE_HSI, VI6_DPR_HSI_ROUTE },
		{ VI6_DPR_NODE_HST, VI6_DPR_HST_ROUTE },
		{ VI6_DPR_NODE_LIF, 0 },
		{ VI6_DPR_NODE_RPF(0), VI6_DPR_RPF_ROUTE(0) },
		{ VI6_DPR_NODE_RPF(1), VI6_DPR_RPF_ROUTE(1) },
		{ VI6_DPR_NODE_RPF(2), VI6_DPR_RPF_ROUTE(2) },
		{ VI6_DPR_NODE_RPF(3), VI6_DPR_RPF_ROUTE(3) },
		{ VI6_DPR_NODE_RPF(4), VI6_DPR_RPF_ROUTE(4) },
		{ VI6_DPR_NODE_UDS(0), VI6_DPR_UDS_ROUTE(0) },
		{ VI6_DPR_NODE_UDS(1), VI6_DPR_UDS_ROUTE(1) },
		{ VI6_DPR_NODE_UDS(2), VI6_DPR_UDS_ROUTE(2) },
		{ VI6_DPR_NODE_WPF(0), 0 },
		{ VI6_DPR_NODE_WPF(1), 0 },
		{ VI6_DPR_NODE_WPF(2), 0 },
		{ VI6_DPR_NODE_WPF(3), 0 },
	};

	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(routes); ++i) {
		if (routes[i].id == entity->id) {
			entity->route = routes[i].reg;
			break;
		}
	}

	if (i == ARRAY_SIZE(routes))
		return -EINVAL;

	entity->vsp1 = vsp1;
	entity->source_pad = num_pads - 1;

	/* Allocate formats and pads. */
	entity->formats = devm_kzalloc(vsp1->dev,
				       num_pads * sizeof(*entity->formats),
				       GFP_KERNEL);
	if (entity->formats == NULL)
		return -ENOMEM;

	entity->pads = devm_kzalloc(vsp1->dev, num_pads * sizeof(*entity->pads),
				    GFP_KERNEL);
	if (entity->pads == NULL)
		return -ENOMEM;

	/* Initialize pads. */
	for (i = 0; i < num_pads - 1; ++i)
		entity->pads[i].flags = MEDIA_PAD_FL_SINK;

	entity->pads[num_pads - 1].flags = MEDIA_PAD_FL_SOURCE;

	/* Initialize the media entity. */
	return media_entity_init(&entity->subdev.entity, num_pads,
				 entity->pads, 0);
}

void vsp1_entity_destroy(struct vsp1_entity *entity)
{
	media_entity_cleanup(&entity->subdev.entity);
}
Commit	Line	Data
26e0ca22 LP	1	/*
	2	* vsp1_entity.c -- R-Car VSP1 Base Entity
	3	*
	4	* Copyright (C) 2013 Renesas Corporation
	5	*
	6	* Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*/
	13
	14	#include <linux/device.h>
	15	#include <linux/gfp.h>
	16
	17	#include <media/media-entity.h>
	18	#include <media/v4l2-subdev.h>
	19
	20	#include "vsp1.h"
	21	#include "vsp1_entity.h"
	22
	23	/* -----------------------------------------------------------------------------
	24	* V4L2 Subdevice Operations
	25	*/
	26
	27	struct v4l2_mbus_framefmt *
	28	vsp1_entity_get_pad_format(struct vsp1_entity *entity,
	29	struct v4l2_subdev_fh *fh,
	30	unsigned int pad, u32 which)
	31	{
	32	switch (which) {
	33	case V4L2_SUBDEV_FORMAT_TRY:
	34	return v4l2_subdev_get_try_format(fh, pad);
	35	case V4L2_SUBDEV_FORMAT_ACTIVE:
	36	return &entity->formats[pad];
	37	default:
	38	return NULL;
	39	}
	40	}
	41
	42	/*
	43	* vsp1_entity_init_formats - Initialize formats on all pads
	44	* @subdev: V4L2 subdevice
	45	* @fh: V4L2 subdev file handle
	46	*
	47	* Initialize all pad formats with default values. If fh is not NULL, try
	48	* formats are initialized on the file handle. Otherwise active formats are
	49	* initialized on the device.
	50	*/
	51	void vsp1_entity_init_formats(struct v4l2_subdev *subdev,
	52	struct v4l2_subdev_fh *fh)
	53	{
	54	struct v4l2_subdev_format format;
	55	unsigned int pad;
	56
	57	for (pad = 0; pad < subdev->entity.num_pads - 1; ++pad) {
	58	memset(&format, 0, sizeof(format));
	59
	60	format.pad = pad;
	61	format.which = fh ? V4L2_SUBDEV_FORMAT_TRY
	62	: V4L2_SUBDEV_FORMAT_ACTIVE;
	63
	64	v4l2_subdev_call(subdev, pad, set_fmt, fh, &format);
65	}
66	}
67
68	static int vsp1_entity_open(struct v4l2_subdev *subdev,
69	struct v4l2_subdev_fh *fh)
70	{
71	vsp1_entity_init_formats(subdev, fh);
72
73	return 0;
74	}
75
76	const struct v4l2_subdev_internal_ops vsp1_subdev_internal_ops = {
77	.open = vsp1_entity_open,
78	};
79
80	/* -----------------------------------------------------------------------------
81	* Media Operations
82	*/
83
84	static int vsp1_entity_link_setup(struct media_entity *entity,
85	const struct media_pad *local,
86	const struct media_pad *remote, u32 flags)
87	{
88	struct vsp1_entity *source;
89
90	if (!(local->flags & MEDIA_PAD_FL_SOURCE))
91	return 0;
92
93	source = container_of(local->entity, struct vsp1_entity, subdev.entity);
94
95	if (!source->route)
96	return 0;
97
98	if (flags & MEDIA_LNK_FL_ENABLED) {
99	if (source->sink)
100	return -EBUSY;
101	source->sink = remote->entity;
102	} else {
103	source->sink = NULL;
104	}
105
106	return 0;
107	}
108
109	const struct media_entity_operations vsp1_media_ops = {
110	.link_setup = vsp1_entity_link_setup,
111	.link_validate = v4l2_subdev_link_validate,
112	};
113
114	/* -----------------------------------------------------------------------------
115	* Initialization
116	*/
117
118	int vsp1_entity_init(struct vsp1_device vsp1, struct vsp1_entity entity,
119	unsigned int num_pads)
120	{
121	static const struct {
122	unsigned int id;
123	unsigned int reg;
124	} routes[] = {
5cdf5741 LP	125	{ VI6_DPR_NODE_HSI, VI6_DPR_HSI_ROUTE },
5cdf5741 LP	126	{ VI6_DPR_NODE_HST, VI6_DPR_HST_ROUTE },
26e0ca22 LP	127	{ VI6_DPR_NODE_LIF, 0 },
	128	{ VI6_DPR_NODE_RPF(0), VI6_DPR_RPF_ROUTE(0) },
	129	{ VI6_DPR_NODE_RPF(1), VI6_DPR_RPF_ROUTE(1) },
	130	{ VI6_DPR_NODE_RPF(2), VI6_DPR_RPF_ROUTE(2) },
	131	{ VI6_DPR_NODE_RPF(3), VI6_DPR_RPF_ROUTE(3) },
	132	{ VI6_DPR_NODE_RPF(4), VI6_DPR_RPF_ROUTE(4) },
	133	{ VI6_DPR_NODE_UDS(0), VI6_DPR_UDS_ROUTE(0) },
	134	{ VI6_DPR_NODE_UDS(1), VI6_DPR_UDS_ROUTE(1) },
	135	{ VI6_DPR_NODE_UDS(2), VI6_DPR_UDS_ROUTE(2) },
	136	{ VI6_DPR_NODE_WPF(0), 0 },
	137	{ VI6_DPR_NODE_WPF(1), 0 },
	138	{ VI6_DPR_NODE_WPF(2), 0 },
	139	{ VI6_DPR_NODE_WPF(3), 0 },
	140	};
	141
	142	unsigned int i;
	143
	144	for (i = 0; i < ARRAY_SIZE(routes); ++i) {
	145	if (routes[i].id == entity->id) {
	146	entity->route = routes[i].reg;
	147	break;
	148	}
	149	}
	150
	151	if (i == ARRAY_SIZE(routes))
	152	return -EINVAL;
	153
	154	entity->vsp1 = vsp1;
	155	entity->source_pad = num_pads - 1;
	156
	157	/* Allocate formats and pads. */
	158	entity->formats = devm_kzalloc(vsp1->dev,
	159	num_pads * sizeof(*entity->formats),
	160	GFP_KERNEL);
	161	if (entity->formats == NULL)
	162	return -ENOMEM;
	163
	164	entity->pads = devm_kzalloc(vsp1->dev, num_pads * sizeof(*entity->pads),
	165	GFP_KERNEL);
	166	if (entity->pads == NULL)
	167	return -ENOMEM;
	168
	169	/* Initialize pads. */
	170	for (i = 0; i < num_pads - 1; ++i)
	171	entity->pads[i].flags = MEDIA_PAD_FL_SINK;
	172
	173	entity->pads[num_pads - 1].flags = MEDIA_PAD_FL_SOURCE;
	174
	175	/* Initialize the media entity. */
	176	return media_entity_init(&entity->subdev.entity, num_pads,
	177	entity->pads, 0);
	178	}
	179
	180	void vsp1_entity_destroy(struct vsp1_entity *entity)
	181	{
	182	media_entity_cleanup(&entity->subdev.entity);
	183	}