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

/*
 * vsp1_entity.c  --  R-Car VSP1 Base Entity
 *
 * Copyright (C) 2013-2014 Renesas Electronics 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-ctrls.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;
		source->sink_pad = remote->index;
	} else {
		source->sink = NULL;
		source->sink_pad = 0;
	}

	return 0;
}

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

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

static const struct vsp1_route vsp1_routes[] = {
	{ VSP1_ENTITY_HSI, 0, VI6_DPR_HSI_ROUTE, { VI6_DPR_NODE_HSI, } },
	{ VSP1_ENTITY_HST, 0, VI6_DPR_HST_ROUTE, { VI6_DPR_NODE_HST, } },
	{ VSP1_ENTITY_LIF, 0, 0, { VI6_DPR_NODE_LIF, } },
	{ VSP1_ENTITY_LUT, 0, VI6_DPR_LUT_ROUTE, { VI6_DPR_NODE_LUT, } },
	{ VSP1_ENTITY_RPF, 0, VI6_DPR_RPF_ROUTE(0), { VI6_DPR_NODE_RPF(0), } },
	{ VSP1_ENTITY_RPF, 1, VI6_DPR_RPF_ROUTE(1), { VI6_DPR_NODE_RPF(1), } },
	{ VSP1_ENTITY_RPF, 2, VI6_DPR_RPF_ROUTE(2), { VI6_DPR_NODE_RPF(2), } },
	{ VSP1_ENTITY_RPF, 3, VI6_DPR_RPF_ROUTE(3), { VI6_DPR_NODE_RPF(3), } },
	{ VSP1_ENTITY_RPF, 4, VI6_DPR_RPF_ROUTE(4), { VI6_DPR_NODE_RPF(4), } },
	{ VSP1_ENTITY_SRU, 0, VI6_DPR_SRU_ROUTE, { VI6_DPR_NODE_SRU, } },
	{ VSP1_ENTITY_UDS, 0, VI6_DPR_UDS_ROUTE(0), { VI6_DPR_NODE_UDS(0), } },
	{ VSP1_ENTITY_UDS, 1, VI6_DPR_UDS_ROUTE(1), { VI6_DPR_NODE_UDS(1), } },
	{ VSP1_ENTITY_UDS, 2, VI6_DPR_UDS_ROUTE(2), { VI6_DPR_NODE_UDS(2), } },
	{ VSP1_ENTITY_WPF, 0, 0, { VI6_DPR_NODE_WPF(0), } },
	{ VSP1_ENTITY_WPF, 1, 0, { VI6_DPR_NODE_WPF(1), } },
	{ VSP1_ENTITY_WPF, 2, 0, { VI6_DPR_NODE_WPF(2), } },
	{ VSP1_ENTITY_WPF, 3, 0, { VI6_DPR_NODE_WPF(3), } },
};

int vsp1_entity_init(struct vsp1_device *vsp1, struct vsp1_entity *entity,
		     unsigned int num_pads)
{
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(vsp1_routes); ++i) {
		if (vsp1_routes[i].type == entity->type &&
		    vsp1_routes[i].index == entity->index) {
			entity->route = &vsp1_routes[i];
			break;
		}
	}

	if (i == ARRAY_SIZE(vsp1_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)
{
	if (entity->subdev.ctrl_handler)
		v4l2_ctrl_handler_free(entity->subdev.ctrl_handler);
	media_entity_cleanup(&entity->subdev.entity);
}
Commit	Line	Data
26e0ca22 LP	1	/*
	2	* vsp1_entity.c -- R-Car VSP1 Base Entity
	3	*
8a1edc55	4	* Copyright (C) 2013-2014 Renesas Electronics Corporation
26e0ca22 LP	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>
a626e64e	18	#include <media/v4l2-ctrls.h>
26e0ca22 LP	19	#include <media/v4l2-subdev.h>
	20
	21	#include "vsp1.h"
	22	#include "vsp1_entity.h"
	23
	24	/* -----------------------------------------------------------------------------
	25	* V4L2 Subdevice Operations
	26	*/
	27
	28	struct v4l2_mbus_framefmt *
	29	vsp1_entity_get_pad_format(struct vsp1_entity *entity,
	30	struct v4l2_subdev_fh *fh,
	31	unsigned int pad, u32 which)
	32	{
	33	switch (which) {
	34	case V4L2_SUBDEV_FORMAT_TRY:
	35	return v4l2_subdev_get_try_format(fh, pad);
	36	case V4L2_SUBDEV_FORMAT_ACTIVE:
	37	return &entity->formats[pad];
	38	default:
	39	return NULL;
	40	}
	41	}
	42
	43	/*
	44	* vsp1_entity_init_formats - Initialize formats on all pads
	45	* @subdev: V4L2 subdevice
	46	* @fh: V4L2 subdev file handle
	47	*
	48	* Initialize all pad formats with default values. If fh is not NULL, try
	49	* formats are initialized on the file handle. Otherwise active formats are
	50	* initialized on the device.
	51	*/
	52	void vsp1_entity_init_formats(struct v4l2_subdev *subdev,
	53	struct v4l2_subdev_fh *fh)
	54	{
	55	struct v4l2_subdev_format format;
	56	unsigned int pad;
	57
	58	for (pad = 0; pad < subdev->entity.num_pads - 1; ++pad) {
	59	memset(&format, 0, sizeof(format));
	60
	61	format.pad = pad;
	62	format.which = fh ? V4L2_SUBDEV_FORMAT_TRY
	63	: V4L2_SUBDEV_FORMAT_ACTIVE;
	64
	65	v4l2_subdev_call(subdev, pad, set_fmt, fh, &format);
	66	}
	67	}
	68
	69	static int vsp1_entity_open(struct v4l2_subdev *subdev,
	70	struct v4l2_subdev_fh *fh)
	71	{
	72	vsp1_entity_init_formats(subdev, fh);
	73
	74	return 0;
	75	}
	76
	77	const struct v4l2_subdev_internal_ops vsp1_subdev_internal_ops = {
	78	.open = vsp1_entity_open,
	79	};
	80
	81	/* -----------------------------------------------------------------------------
	82	* Media Operations
83	*/
84
85	static int vsp1_entity_link_setup(struct media_entity *entity,
86	const struct media_pad *local,
87	const struct media_pad *remote, u32 flags)
88	{
89	struct vsp1_entity *source;
90
91	if (!(local->flags & MEDIA_PAD_FL_SOURCE))
92	return 0;
93
94	source = container_of(local->entity, struct vsp1_entity, subdev.entity);
95
96	if (!source->route)
97	return 0;
98
99	if (flags & MEDIA_LNK_FL_ENABLED) {
100	if (source->sink)
101	return -EBUSY;
102	source->sink = remote->entity;
d9b45ed3	103	source->sink_pad = remote->index;
26e0ca22 LP	104	} else {
26e0ca22 LP	105	source->sink = NULL;
d9b45ed3	106	source->sink_pad = 0;
26e0ca22 LP	107	}
	108
	109	return 0;
	110	}
	111
	112	const struct media_entity_operations vsp1_media_ops = {
	113	.link_setup = vsp1_entity_link_setup,
	114	.link_validate = v4l2_subdev_link_validate,
	115	};
	116
	117	/* -----------------------------------------------------------------------------
	118	* Initialization
	119	*/
	120
d9b45ed3 LP	121	static const struct vsp1_route vsp1_routes[] = {
	122	{ VSP1_ENTITY_HSI, 0, VI6_DPR_HSI_ROUTE, { VI6_DPR_NODE_HSI, } },
	123	{ VSP1_ENTITY_HST, 0, VI6_DPR_HST_ROUTE, { VI6_DPR_NODE_HST, } },
	124	{ VSP1_ENTITY_LIF, 0, 0, { VI6_DPR_NODE_LIF, } },
	125	{ VSP1_ENTITY_LUT, 0, VI6_DPR_LUT_ROUTE, { VI6_DPR_NODE_LUT, } },
	126	{ VSP1_ENTITY_RPF, 0, VI6_DPR_RPF_ROUTE(0), { VI6_DPR_NODE_RPF(0), } },
	127	{ VSP1_ENTITY_RPF, 1, VI6_DPR_RPF_ROUTE(1), { VI6_DPR_NODE_RPF(1), } },
	128	{ VSP1_ENTITY_RPF, 2, VI6_DPR_RPF_ROUTE(2), { VI6_DPR_NODE_RPF(2), } },
	129	{ VSP1_ENTITY_RPF, 3, VI6_DPR_RPF_ROUTE(3), { VI6_DPR_NODE_RPF(3), } },
	130	{ VSP1_ENTITY_RPF, 4, VI6_DPR_RPF_ROUTE(4), { VI6_DPR_NODE_RPF(4), } },
	131	{ VSP1_ENTITY_SRU, 0, VI6_DPR_SRU_ROUTE, { VI6_DPR_NODE_SRU, } },
	132	{ VSP1_ENTITY_UDS, 0, VI6_DPR_UDS_ROUTE(0), { VI6_DPR_NODE_UDS(0), } },
	133	{ VSP1_ENTITY_UDS, 1, VI6_DPR_UDS_ROUTE(1), { VI6_DPR_NODE_UDS(1), } },
	134	{ VSP1_ENTITY_UDS, 2, VI6_DPR_UDS_ROUTE(2), { VI6_DPR_NODE_UDS(2), } },
	135	{ VSP1_ENTITY_WPF, 0, 0, { VI6_DPR_NODE_WPF(0), } },
	136	{ VSP1_ENTITY_WPF, 1, 0, { VI6_DPR_NODE_WPF(1), } },
	137	{ VSP1_ENTITY_WPF, 2, 0, { VI6_DPR_NODE_WPF(2), } },
	138	{ VSP1_ENTITY_WPF, 3, 0, { VI6_DPR_NODE_WPF(3), } },
	139	};
	140
26e0ca22 LP	141	int vsp1_entity_init(struct vsp1_device vsp1, struct vsp1_entity entity,
	142	unsigned int num_pads)
	143	{
26e0ca22 LP	144	unsigned int i;
26e0ca22 LP	145
d9b45ed3 LP	146	for (i = 0; i < ARRAY_SIZE(vsp1_routes); ++i) {
	147	if (vsp1_routes[i].type == entity->type &&
	148	vsp1_routes[i].index == entity->index) {
	149	entity->route = &vsp1_routes[i];
26e0ca22 LP	150	break;
	151	}
	152	}
	153
d9b45ed3	154	if (i == ARRAY_SIZE(vsp1_routes))
26e0ca22 LP	155	return -EINVAL;
	156
	157	entity->vsp1 = vsp1;
	158	entity->source_pad = num_pads - 1;
	159
	160	/* Allocate formats and pads. */
	161	entity->formats = devm_kzalloc(vsp1->dev,
	162	num_pads * sizeof(*entity->formats),
	163	GFP_KERNEL);
	164	if (entity->formats == NULL)
	165	return -ENOMEM;
	166
	167	entity->pads = devm_kzalloc(vsp1->dev, num_pads * sizeof(*entity->pads),
	168	GFP_KERNEL);
	169	if (entity->pads == NULL)
	170	return -ENOMEM;
	171
	172	/* Initialize pads. */
	173	for (i = 0; i < num_pads - 1; ++i)
	174	entity->pads[i].flags = MEDIA_PAD_FL_SINK;
	175
	176	entity->pads[num_pads - 1].flags = MEDIA_PAD_FL_SOURCE;
	177
	178	/* Initialize the media entity. */
	179	return media_entity_init(&entity->subdev.entity, num_pads,
	180	entity->pads, 0);
	181	}
	182
	183	void vsp1_entity_destroy(struct vsp1_entity *entity)
	184	{
a626e64e LP	185	if (entity->subdev.ctrl_handler)
a626e64e LP	186	v4l2_ctrl_handler_free(entity->subdev.ctrl_handler);
26e0ca22 LP	187	media_entity_cleanup(&entity->subdev.entity);
26e0ca22 LP	188	}