[deliverable/linux.git] / drivers / media / platform / s5p-tv / mixer_vp_layer.c

/*
 * Samsung TV Mixer driver
 *
 * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
 *
 * Tomasz Stanislawski, <t.stanislaws@samsung.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 Foundiation. either version 2 of the License,
 * or (at your option) any later version
 */

#include "mixer.h"

#include "regs-vp.h"

#include <media/videobuf2-dma-contig.h>

/* FORMAT DEFINITIONS */
static const struct mxr_format mxr_fmt_nv12 = {
	.name = "NV12",
	.fourcc = V4L2_PIX_FMT_NV12,
	.colorspace = V4L2_COLORSPACE_JPEG,
	.num_planes = 2,
	.plane = {
		{ .width = 1, .height = 1, .size = 1 },
		{ .width = 2, .height = 2, .size = 2 },
	},
	.num_subframes = 1,
	.cookie = VP_MODE_NV12 | VP_MODE_MEM_LINEAR,
};

static const struct mxr_format mxr_fmt_nv21 = {
	.name = "NV21",
	.fourcc = V4L2_PIX_FMT_NV21,
	.colorspace = V4L2_COLORSPACE_JPEG,
	.num_planes = 2,
	.plane = {
		{ .width = 1, .height = 1, .size = 1 },
		{ .width = 2, .height = 2, .size = 2 },
	},
	.num_subframes = 1,
	.cookie = VP_MODE_NV21 | VP_MODE_MEM_LINEAR,
};

static const struct mxr_format mxr_fmt_nv12m = {
	.name = "NV12 (mplane)",
	.fourcc = V4L2_PIX_FMT_NV12M,
	.colorspace = V4L2_COLORSPACE_JPEG,
	.num_planes = 2,
	.plane = {
		{ .width = 1, .height = 1, .size = 1 },
		{ .width = 2, .height = 2, .size = 2 },
	},
	.num_subframes = 2,
	.plane2subframe = {0, 1},
	.cookie = VP_MODE_NV12 | VP_MODE_MEM_LINEAR,
};

static const struct mxr_format mxr_fmt_nv12mt = {
	.name = "NV12 tiled (mplane)",
	.fourcc = V4L2_PIX_FMT_NV12MT,
	.colorspace = V4L2_COLORSPACE_JPEG,
	.num_planes = 2,
	.plane = {
		{ .width = 128, .height = 32, .size = 4096 },
		{ .width = 128, .height = 32, .size = 2048 },
	},
	.num_subframes = 2,
	.plane2subframe = {0, 1},
	.cookie = VP_MODE_NV12 | VP_MODE_MEM_TILED,
};

static const struct mxr_format *mxr_video_format[] = {
	&mxr_fmt_nv12,
	&mxr_fmt_nv21,
	&mxr_fmt_nv12m,
	&mxr_fmt_nv12mt,
};

/* AUXILIARY CALLBACKS */

static void mxr_vp_layer_release(struct mxr_layer *layer)
{
	mxr_base_layer_unregister(layer);
	mxr_base_layer_release(layer);
}

static void mxr_vp_buffer_set(struct mxr_layer *layer,
	struct mxr_buffer *buf)
{
	dma_addr_t luma_addr[2] = {0, 0};
	dma_addr_t chroma_addr[2] = {0, 0};

	if (buf == NULL) {
		mxr_reg_vp_buffer(layer->mdev, luma_addr, chroma_addr);
		return;
	}
	luma_addr[0] = vb2_dma_contig_plane_dma_addr(&buf->vb.vb2_buf, 0);
	if (layer->fmt->num_subframes == 2) {
		chroma_addr[0] =
			vb2_dma_contig_plane_dma_addr(&buf->vb.vb2_buf, 1);
	} else {
		/* FIXME: mxr_get_plane_size compute integer division,
		 * which is slow and should not be performed in interrupt */
		chroma_addr[0] = luma_addr[0] + mxr_get_plane_size(
			&layer->fmt->plane[0], layer->geo.src.full_width,
			layer->geo.src.full_height);
	}
	if (layer->fmt->cookie & VP_MODE_MEM_TILED) {
		luma_addr[1] = luma_addr[0] + 0x40;
		chroma_addr[1] = chroma_addr[0] + 0x40;
	} else {
		luma_addr[1] = luma_addr[0] + layer->geo.src.full_width;
		chroma_addr[1] = chroma_addr[0];
	}
	mxr_reg_vp_buffer(layer->mdev, luma_addr, chroma_addr);
}

static void mxr_vp_stream_set(struct mxr_layer *layer, int en)
{
	mxr_reg_vp_layer_stream(layer->mdev, en);
}

static void mxr_vp_format_set(struct mxr_layer *layer)
{
	mxr_reg_vp_format(layer->mdev, layer->fmt, &layer->geo);
}

static inline unsigned int do_center(unsigned int center,
	unsigned int size, unsigned int upper, unsigned int flags)
{
	unsigned int lower;

	if (flags & MXR_NO_OFFSET)
		return 0;

	lower = center - min(center, size / 2);
	return min(lower, upper - size);
}

static void mxr_vp_fix_geometry(struct mxr_layer *layer,
	enum mxr_geometry_stage stage, unsigned long flags)
{
	struct mxr_geometry *geo = &layer->geo;
	struct mxr_crop *src = &geo->src;
	struct mxr_crop *dst = &geo->dst;
	unsigned long x_center, y_center;

	switch (stage) {

	case MXR_GEOMETRY_SINK: /* nothing to be fixed here */
	case MXR_GEOMETRY_COMPOSE:
		/* remember center of the area */
		x_center = dst->x_offset + dst->width / 2;
		y_center = dst->y_offset + dst->height / 2;

		/* ensure that compose is reachable using 16x scaling */
		dst->width = clamp(dst->width, 8U, 16 * src->full_width);
		dst->height = clamp(dst->height, 1U, 16 * src->full_height);

		/* setup offsets */
		dst->x_offset = do_center(x_center, dst->width,
			dst->full_width, flags);
		dst->y_offset = do_center(y_center, dst->height,
			dst->full_height, flags);
		flags = 0; /* remove possible MXR_NO_OFFSET flag */
		/* fall through */
	case MXR_GEOMETRY_CROP:
		/* remember center of the area */
		x_center = src->x_offset + src->width / 2;
		y_center = src->y_offset + src->height / 2;

		/* ensure scaling is between 0.25x .. 16x */
		src->width = clamp(src->width, round_up(dst->width / 16, 4),
			dst->width * 4);
		src->height = clamp(src->height, round_up(dst->height / 16, 4),
			dst->height * 4);

		/* hardware limits */
		src->width = clamp(src->width, 32U, 2047U);
		src->height = clamp(src->height, 4U, 2047U);

		/* setup offsets */
		src->x_offset = do_center(x_center, src->width,
			src->full_width, flags);
		src->y_offset = do_center(y_center, src->height,
			src->full_height, flags);

		/* setting scaling ratio */
		geo->x_ratio = (src->width << 16) / dst->width;
		geo->y_ratio = (src->height << 16) / dst->height;
		/* fall through */

	case MXR_GEOMETRY_SOURCE:
		src->full_width = clamp(src->full_width,
			ALIGN(src->width + src->x_offset, 8), 8192U);
		src->full_height = clamp(src->full_height,
			src->height + src->y_offset, 8192U);
	}
}

/* PUBLIC API */

struct mxr_layer *mxr_vp_layer_create(struct mxr_device *mdev, int idx)
{
	struct mxr_layer *layer;
	int ret;
	const struct mxr_layer_ops ops = {
		.release = mxr_vp_layer_release,
		.buffer_set = mxr_vp_buffer_set,
		.stream_set = mxr_vp_stream_set,
		.format_set = mxr_vp_format_set,
		.fix_geometry = mxr_vp_fix_geometry,
	};
	char name[32];

	sprintf(name, "video%d", idx);

	layer = mxr_base_layer_create(mdev, idx, name, &ops);
	if (layer == NULL) {
		mxr_err(mdev, "failed to initialize layer(%d) base\n", idx);
		goto fail;
	}

	layer->fmt_array = mxr_video_format;
	layer->fmt_array_size = ARRAY_SIZE(mxr_video_format);

	ret = mxr_base_layer_register(layer);
	if (ret)
		goto fail_layer;

	return layer;

fail_layer:
	mxr_base_layer_release(layer);

fail:
	return NULL;
}
Commit	Line	Data
fef1c8d0 TS	1	/*
	2	* Samsung TV Mixer driver
	3	*
	4	* Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
	5	*
	6	* Tomasz Stanislawski, <t.stanislaws@samsung.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
	10	* by the Free Software Foundiation. either version 2 of the License,
	11	* or (at your option) any later version
	12	*/
	13
	14	#include "mixer.h"
	15
	16	#include "regs-vp.h"
	17
	18	#include <media/videobuf2-dma-contig.h>
	19
	20	/* FORMAT DEFINITIONS */
	21	static const struct mxr_format mxr_fmt_nv12 = {
	22	.name = "NV12",
	23	.fourcc = V4L2_PIX_FMT_NV12,
	24	.colorspace = V4L2_COLORSPACE_JPEG,
	25	.num_planes = 2,
	26	.plane = {
	27	{ .width = 1, .height = 1, .size = 1 },
	28	{ .width = 2, .height = 2, .size = 2 },
	29	},
	30	.num_subframes = 1,
	31	.cookie = VP_MODE_NV12 \| VP_MODE_MEM_LINEAR,
	32	};
	33
	34	static const struct mxr_format mxr_fmt_nv21 = {
	35	.name = "NV21",
	36	.fourcc = V4L2_PIX_FMT_NV21,
	37	.colorspace = V4L2_COLORSPACE_JPEG,
	38	.num_planes = 2,
	39	.plane = {
	40	{ .width = 1, .height = 1, .size = 1 },
	41	{ .width = 2, .height = 2, .size = 2 },
	42	},
	43	.num_subframes = 1,
	44	.cookie = VP_MODE_NV21 \| VP_MODE_MEM_LINEAR,
	45	};
	46
	47	static const struct mxr_format mxr_fmt_nv12m = {
	48	.name = "NV12 (mplane)",
	49	.fourcc = V4L2_PIX_FMT_NV12M,
	50	.colorspace = V4L2_COLORSPACE_JPEG,
	51	.num_planes = 2,
	52	.plane = {
	53	{ .width = 1, .height = 1, .size = 1 },
	54	{ .width = 2, .height = 2, .size = 2 },
	55	},
	56	.num_subframes = 2,
	57	.plane2subframe = {0, 1},
	58	.cookie = VP_MODE_NV12 \| VP_MODE_MEM_LINEAR,
	59	};
	60
	61	static const struct mxr_format mxr_fmt_nv12mt = {
	62	.name = "NV12 tiled (mplane)",
	63	.fourcc = V4L2_PIX_FMT_NV12MT,
	64	.colorspace = V4L2_COLORSPACE_JPEG,
65	.num_planes = 2,
66	.plane = {
67	{ .width = 128, .height = 32, .size = 4096 },
68	{ .width = 128, .height = 32, .size = 2048 },
69	},
70	.num_subframes = 2,
71	.plane2subframe = {0, 1},
72	.cookie = VP_MODE_NV12 \| VP_MODE_MEM_TILED,
73	};
74
75	static const struct mxr_format *mxr_video_format[] = {
76	&mxr_fmt_nv12,
77	&mxr_fmt_nv21,
78	&mxr_fmt_nv12m,
79	&mxr_fmt_nv12mt,
80	};
81
82	/* AUXILIARY CALLBACKS */
83
84	static void mxr_vp_layer_release(struct mxr_layer *layer)
85	{
86	mxr_base_layer_unregister(layer);
87	mxr_base_layer_release(layer);
88	}
89
90	static void mxr_vp_buffer_set(struct mxr_layer *layer,
91	struct mxr_buffer *buf)
92	{
93	dma_addr_t luma_addr[2] = {0, 0};
94	dma_addr_t chroma_addr[2] = {0, 0};
95
96	if (buf == NULL) {
97	mxr_reg_vp_buffer(layer->mdev, luma_addr, chroma_addr);
98	return;
99	}
2d700715	100	luma_addr[0] = vb2_dma_contig_plane_dma_addr(&buf->vb.vb2_buf, 0);
fef1c8d0	101	if (layer->fmt->num_subframes == 2) {
2d700715 JS	102	chroma_addr[0] =
2d700715 JS	103	vb2_dma_contig_plane_dma_addr(&buf->vb.vb2_buf, 1);
fef1c8d0 TS	104	} else {
	105	/* FIXME: mxr_get_plane_size compute integer division,
	106	* which is slow and should not be performed in interrupt */
	107	chroma_addr[0] = luma_addr[0] + mxr_get_plane_size(
	108	&layer->fmt->plane[0], layer->geo.src.full_width,
	109	layer->geo.src.full_height);
	110	}
	111	if (layer->fmt->cookie & VP_MODE_MEM_TILED) {
	112	luma_addr[1] = luma_addr[0] + 0x40;
	113	chroma_addr[1] = chroma_addr[0] + 0x40;
	114	} else {
	115	luma_addr[1] = luma_addr[0] + layer->geo.src.full_width;
	116	chroma_addr[1] = chroma_addr[0];
	117	}
	118	mxr_reg_vp_buffer(layer->mdev, luma_addr, chroma_addr);
	119	}
	120
	121	static void mxr_vp_stream_set(struct mxr_layer *layer, int en)
	122	{
	123	mxr_reg_vp_layer_stream(layer->mdev, en);
	124	}
	125
	126	static void mxr_vp_format_set(struct mxr_layer *layer)
	127	{
	128	mxr_reg_vp_format(layer->mdev, layer->fmt, &layer->geo);
	129	}
	130
0d066d3f TS	131	static inline unsigned int do_center(unsigned int center,
0d066d3f TS	132	unsigned int size, unsigned int upper, unsigned int flags)
fef1c8d0	133	{
0d066d3f TS	134	unsigned int lower;
	135
	136	if (flags & MXR_NO_OFFSET)
	137	return 0;
	138
	139	lower = center - min(center, size / 2);
	140	return min(lower, upper - size);
	141	}
fef1c8d0	142
0d066d3f TS	143	static void mxr_vp_fix_geometry(struct mxr_layer *layer,
	144	enum mxr_geometry_stage stage, unsigned long flags)
	145	{
	146	struct mxr_geometry *geo = &layer->geo;
	147	struct mxr_crop *src = &geo->src;
	148	struct mxr_crop *dst = &geo->dst;
	149	unsigned long x_center, y_center;
	150
	151	switch (stage) {
	152
	153	case MXR_GEOMETRY_SINK: /* nothing to be fixed here */
	154	case MXR_GEOMETRY_COMPOSE:
	155	/* remember center of the area */
	156	x_center = dst->x_offset + dst->width / 2;
	157	y_center = dst->y_offset + dst->height / 2;
	158
	159	/* ensure that compose is reachable using 16x scaling */
	160	dst->width = clamp(dst->width, 8U, 16 * src->full_width);
	161	dst->height = clamp(dst->height, 1U, 16 * src->full_height);
	162
	163	/* setup offsets */
	164	dst->x_offset = do_center(x_center, dst->width,
	165	dst->full_width, flags);
	166	dst->y_offset = do_center(y_center, dst->height,
	167	dst->full_height, flags);
	168	flags = 0; /* remove possible MXR_NO_OFFSET flag */
	169	/* fall through */
	170	case MXR_GEOMETRY_CROP:
	171	/* remember center of the area */
	172	x_center = src->x_offset + src->width / 2;
	173	y_center = src->y_offset + src->height / 2;
	174
	175	/* ensure scaling is between 0.25x .. 16x */
392d9e1d TS	176	src->width = clamp(src->width, round_up(dst->width / 16, 4),
	177	dst->width * 4);
	178	src->height = clamp(src->height, round_up(dst->height / 16, 4),
	179	dst->height * 4);
0d066d3f TS	180
	181	/* hardware limits */
	182	src->width = clamp(src->width, 32U, 2047U);
	183	src->height = clamp(src->height, 4U, 2047U);
	184
	185	/* setup offsets */
	186	src->x_offset = do_center(x_center, src->width,
	187	src->full_width, flags);
	188	src->y_offset = do_center(y_center, src->height,
	189	src->full_height, flags);
	190
	191	/* setting scaling ratio */
	192	geo->x_ratio = (src->width << 16) / dst->width;
	193	geo->y_ratio = (src->height << 16) / dst->height;
	194	/* fall through */
	195
	196	case MXR_GEOMETRY_SOURCE:
	197	src->full_width = clamp(src->full_width,
	198	ALIGN(src->width + src->x_offset, 8), 8192U);
	199	src->full_height = clamp(src->full_height,
	200	src->height + src->y_offset, 8192U);
2028c71d	201	}
fef1c8d0 TS	202	}
	203
	204	/* PUBLIC API */
	205
	206	struct mxr_layer mxr_vp_layer_create(struct mxr_device mdev, int idx)
	207	{
	208	struct mxr_layer *layer;
	209	int ret;
adbedc29	210	const struct mxr_layer_ops ops = {
fef1c8d0 TS	211	.release = mxr_vp_layer_release,
	212	.buffer_set = mxr_vp_buffer_set,
	213	.stream_set = mxr_vp_stream_set,
	214	.format_set = mxr_vp_format_set,
	215	.fix_geometry = mxr_vp_fix_geometry,
	216	};
	217	char name[32];
	218
	219	sprintf(name, "video%d", idx);
	220
	221	layer = mxr_base_layer_create(mdev, idx, name, &ops);
	222	if (layer == NULL) {
	223	mxr_err(mdev, "failed to initialize layer(%d) base\n", idx);
	224	goto fail;
	225	}
	226
	227	layer->fmt_array = mxr_video_format;
	228	layer->fmt_array_size = ARRAY_SIZE(mxr_video_format);
	229
	230	ret = mxr_base_layer_register(layer);
	231	if (ret)
	232	goto fail_layer;
	233
	234	return layer;
	235
	236	fail_layer:
	237	mxr_base_layer_release(layer);
	238
	239	fail:
	240	return NULL;
	241	}
	242