[deliverable/linux.git] / drivers / media / platform / ti-vpe / csc.c

/*
 * Color space converter library
 *
 * Copyright (c) 2013 Texas Instruments Inc.
 *
 * David Griego, <dagriego@biglakesoftware.com>
 * Dale Farnsworth, <dale@farnsworth.org>
 * Archit Taneja, <archit@ti.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */

#include <linux/err.h>
#include <linux/io.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/videodev2.h>

#include "csc.h"

/*
 * 16 coefficients in the order:
 * a0, b0, c0, a1, b1, c1, a2, b2, c2, d0, d1, d2
 * (we may need to pass non-default values from user space later on, we might
 * need to make the coefficient struct more easy to populate)
 */
struct colorspace_coeffs {
	u16	sd[12];
	u16	hd[12];
};

/* VIDEO_RANGE: limited range, GRAPHICS_RANGE: full range */
#define	CSC_COEFFS_VIDEO_RANGE_Y2R	0
#define	CSC_COEFFS_GRAPHICS_RANGE_Y2R	1
#define	CSC_COEFFS_VIDEO_RANGE_R2Y	2
#define	CSC_COEFFS_GRAPHICS_RANGE_R2Y	3

/* default colorspace coefficients */
static struct colorspace_coeffs colorspace_coeffs[4] = {
	[CSC_COEFFS_VIDEO_RANGE_Y2R] = {
		{
			/* SDTV */
			0x0400, 0x0000, 0x057D, 0x0400, 0x1EA7, 0x1D35,
			0x0400, 0x06EF, 0x1FFE, 0x0D40, 0x0210, 0x0C88,
		},
		{
			/* HDTV */
			0x0400, 0x0000, 0x0629, 0x0400, 0x1F45, 0x1E2B,
			0x0400, 0x0742, 0x0000, 0x0CEC, 0x0148, 0x0C60,
		},
	},
	[CSC_COEFFS_GRAPHICS_RANGE_Y2R] = {
		{
			/* SDTV */
			0x04A8, 0x1FFE, 0x0662, 0x04A8, 0x1E6F, 0x1CBF,
			0x04A8, 0x0812, 0x1FFF, 0x0C84, 0x0220, 0x0BAC,
		},
		{
			/* HDTV */
			0x04A8, 0x0000, 0x072C, 0x04A8, 0x1F26, 0x1DDE,
			0x04A8, 0x0873, 0x0000, 0x0C20, 0x0134, 0x0B7C,
		},
	},
	[CSC_COEFFS_VIDEO_RANGE_R2Y] = {
		{
			/* SDTV */
			0x0132, 0x0259, 0x0075, 0x1F50, 0x1EA5, 0x020B,
			0x020B, 0x1E4A, 0x1FAB, 0x0000, 0x0200, 0x0200,
		},
		{
			/* HDTV */
			0x00DA, 0x02DC, 0x004A, 0x1F88, 0x1E6C, 0x020C,
			0x020C, 0x1E24, 0x1FD0, 0x0000, 0x0200, 0x0200,
		},
	},
	[CSC_COEFFS_GRAPHICS_RANGE_R2Y] = {
		{
			/* SDTV */
			0x0107, 0x0204, 0x0064, 0x1F68, 0x1ED6, 0x01C2,
			0x01C2, 0x1E87, 0x1FB7, 0x0040, 0x0200, 0x0200,
		},
		{
			/* HDTV */
			0x04A8, 0x0000, 0x072C, 0x04A8, 0x1F26, 0x1DDE,
			0x04A8, 0x0873, 0x0000, 0x0C20, 0x0134, 0x0B7C,
		},
	},
};

void csc_dump_regs(struct csc_data *csc)
{
	struct device *dev = &csc->pdev->dev;

#define DUMPREG(r) dev_dbg(dev, "%-35s %08x\n", #r, \
	ioread32(csc->base + CSC_##r))

	DUMPREG(CSC00);
	DUMPREG(CSC01);
	DUMPREG(CSC02);
	DUMPREG(CSC03);
	DUMPREG(CSC04);
	DUMPREG(CSC05);

#undef DUMPREG
}

void csc_set_coeff_bypass(struct csc_data *csc, u32 *csc_reg5)
{
	*csc_reg5 |= CSC_BYPASS;
}

/*
 * set the color space converter coefficient shadow register values
 */
void csc_set_coeff(struct csc_data *csc, u32 *csc_reg0,
		enum v4l2_colorspace src_colorspace,
		enum v4l2_colorspace dst_colorspace)
{
	u32 *csc_reg5 = csc_reg0 + 5;
	u32 *shadow_csc = csc_reg0;
	struct colorspace_coeffs *sd_hd_coeffs;
	u16 *coeff, *end_coeff;
	enum v4l2_colorspace yuv_colorspace;
	int sel = 0;

	/*
	 * support only graphics data range(full range) for now, a control ioctl
	 * would be nice here
	 */
	/* Y2R */
	if (dst_colorspace == V4L2_COLORSPACE_SRGB &&
			(src_colorspace == V4L2_COLORSPACE_SMPTE170M ||
			src_colorspace == V4L2_COLORSPACE_REC709)) {
		/* Y2R */
		sel = 1;
		yuv_colorspace = src_colorspace;
	} else if ((dst_colorspace == V4L2_COLORSPACE_SMPTE170M ||
			dst_colorspace == V4L2_COLORSPACE_REC709) &&
			src_colorspace == V4L2_COLORSPACE_SRGB) {
		/* R2Y */
		sel = 3;
		yuv_colorspace = dst_colorspace;
	} else {
		*csc_reg5 |= CSC_BYPASS;
		return;
	}

	sd_hd_coeffs = &colorspace_coeffs[sel];

	/* select between SD or HD coefficients */
	if (yuv_colorspace == V4L2_COLORSPACE_SMPTE170M)
		coeff = sd_hd_coeffs->sd;
	else
		coeff = sd_hd_coeffs->hd;

	end_coeff = coeff + 12;

	for (; coeff < end_coeff; coeff += 2)
		*shadow_csc++ = (*(coeff + 1) << 16) | *coeff;
}

struct csc_data *csc_create(struct platform_device *pdev)
{
	struct csc_data *csc;

	dev_dbg(&pdev->dev, "csc_create\n");

	csc = devm_kzalloc(&pdev->dev, sizeof(*csc), GFP_KERNEL);
	if (!csc) {
		dev_err(&pdev->dev, "couldn't alloc csc_data\n");
		return ERR_PTR(-ENOMEM);
	}

	csc->pdev = pdev;

	csc->res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
			"csc");
	if (csc->res == NULL) {
		dev_err(&pdev->dev, "missing platform resources data\n");
		return ERR_PTR(-ENODEV);
	}

	csc->base = devm_ioremap_resource(&pdev->dev, csc->res);
	if (IS_ERR(csc->base)) {
		dev_err(&pdev->dev, "failed to ioremap\n");
		return ERR_CAST(csc->base);
	}

	return csc;
}
Commit	Line	Data
6948082d AT	1	/*
	2	* Color space converter library
	3	*
	4	* Copyright (c) 2013 Texas Instruments Inc.
	5	*
	6	* David Griego, <dagriego@biglakesoftware.com>
	7	* Dale Farnsworth, <dale@farnsworth.org>
	8	* Archit Taneja, <archit@ti.com>
	9	*
	10	* This program is free software; you can redistribute it and/or modify it
	11	* under the terms of the GNU General Public License version 2 as published by
	12	* the Free Software Foundation.
	13	*/
	14
	15	#include <linux/err.h>
	16	#include <linux/io.h>
	17	#include <linux/platform_device.h>
	18	#include <linux/slab.h>
6c4f4cbb	19	#include <linux/videodev2.h>
6948082d AT	20
	21	#include "csc.h"
	22
6c4f4cbb AT	23	/*
	24	* 16 coefficients in the order:
	25	* a0, b0, c0, a1, b1, c1, a2, b2, c2, d0, d1, d2
	26	* (we may need to pass non-default values from user space later on, we might
	27	* need to make the coefficient struct more easy to populate)
	28	*/
	29	struct colorspace_coeffs {
	30	u16 sd[12];
	31	u16 hd[12];
	32	};
	33
	34	/* VIDEO_RANGE: limited range, GRAPHICS_RANGE: full range */
	35	#define CSC_COEFFS_VIDEO_RANGE_Y2R 0
	36	#define CSC_COEFFS_GRAPHICS_RANGE_Y2R 1
	37	#define CSC_COEFFS_VIDEO_RANGE_R2Y 2
	38	#define CSC_COEFFS_GRAPHICS_RANGE_R2Y 3
	39
	40	/* default colorspace coefficients */
	41	static struct colorspace_coeffs colorspace_coeffs[4] = {
	42	[CSC_COEFFS_VIDEO_RANGE_Y2R] = {
	43	{
	44	/* SDTV */
	45	0x0400, 0x0000, 0x057D, 0x0400, 0x1EA7, 0x1D35,
	46	0x0400, 0x06EF, 0x1FFE, 0x0D40, 0x0210, 0x0C88,
	47	},
	48	{
	49	/* HDTV */
	50	0x0400, 0x0000, 0x0629, 0x0400, 0x1F45, 0x1E2B,
	51	0x0400, 0x0742, 0x0000, 0x0CEC, 0x0148, 0x0C60,
	52	},
	53	},
	54	[CSC_COEFFS_GRAPHICS_RANGE_Y2R] = {
	55	{
	56	/* SDTV */
	57	0x04A8, 0x1FFE, 0x0662, 0x04A8, 0x1E6F, 0x1CBF,
	58	0x04A8, 0x0812, 0x1FFF, 0x0C84, 0x0220, 0x0BAC,
	59	},
	60	{
	61	/* HDTV */
	62	0x04A8, 0x0000, 0x072C, 0x04A8, 0x1F26, 0x1DDE,
	63	0x04A8, 0x0873, 0x0000, 0x0C20, 0x0134, 0x0B7C,
	64	},
	65	},
	66	[CSC_COEFFS_VIDEO_RANGE_R2Y] = {
	67	{
	68	/* SDTV */
	69	0x0132, 0x0259, 0x0075, 0x1F50, 0x1EA5, 0x020B,
	70	0x020B, 0x1E4A, 0x1FAB, 0x0000, 0x0200, 0x0200,
	71	},
	72	{
	73	/* HDTV */
	74	0x00DA, 0x02DC, 0x004A, 0x1F88, 0x1E6C, 0x020C,
	75	0x020C, 0x1E24, 0x1FD0, 0x0000, 0x0200, 0x0200,
	76	},
	77	},
	78	[CSC_COEFFS_GRAPHICS_RANGE_R2Y] = {
	79	{
	80	/* SDTV */
	81	0x0107, 0x0204, 0x0064, 0x1F68, 0x1ED6, 0x01C2,
	82	0x01C2, 0x1E87, 0x1FB7, 0x0040, 0x0200, 0x0200,
	83	},
	84	{
	85	/* HDTV */
	86	0x04A8, 0x0000, 0x072C, 0x04A8, 0x1F26, 0x1DDE,
87	0x04A8, 0x0873, 0x0000, 0x0C20, 0x0134, 0x0B7C,
88	},
89	},
90	};
91
6948082d AT	92	void csc_dump_regs(struct csc_data *csc)
	93	{
	94	struct device *dev = &csc->pdev->dev;
	95
61110fba BW	96	#define DUMPREG(r) dev_dbg(dev, "%-35s %08x\n", #r, \
61110fba BW	97	ioread32(csc->base + CSC_##r))
6948082d AT	98
	99	DUMPREG(CSC00);
	100	DUMPREG(CSC01);
	101	DUMPREG(CSC02);
	102	DUMPREG(CSC03);
	103	DUMPREG(CSC04);
	104	DUMPREG(CSC05);
	105
	106	#undef DUMPREG
	107	}
	108
	109	void csc_set_coeff_bypass(struct csc_data csc, u32 csc_reg5)
	110	{
	111	*csc_reg5 \|= CSC_BYPASS;
	112	}
	113
6c4f4cbb AT	114	/*
	115	* set the color space converter coefficient shadow register values
	116	*/
	117	void csc_set_coeff(struct csc_data csc, u32 csc_reg0,
	118	enum v4l2_colorspace src_colorspace,
	119	enum v4l2_colorspace dst_colorspace)
	120	{
	121	u32 *csc_reg5 = csc_reg0 + 5;
	122	u32 *shadow_csc = csc_reg0;
	123	struct colorspace_coeffs *sd_hd_coeffs;
	124	u16 coeff, end_coeff;
	125	enum v4l2_colorspace yuv_colorspace;
	126	int sel = 0;
	127
	128	/*
	129	* support only graphics data range(full range) for now, a control ioctl
	130	* would be nice here
	131	*/
	132	/* Y2R */
	133	if (dst_colorspace == V4L2_COLORSPACE_SRGB &&
	134	(src_colorspace == V4L2_COLORSPACE_SMPTE170M \|\|
	135	src_colorspace == V4L2_COLORSPACE_REC709)) {
	136	/* Y2R */
	137	sel = 1;
	138	yuv_colorspace = src_colorspace;
	139	} else if ((dst_colorspace == V4L2_COLORSPACE_SMPTE170M \|\|
	140	dst_colorspace == V4L2_COLORSPACE_REC709) &&
	141	src_colorspace == V4L2_COLORSPACE_SRGB) {
	142	/* R2Y */
	143	sel = 3;
	144	yuv_colorspace = dst_colorspace;
	145	} else {
	146	*csc_reg5 \|= CSC_BYPASS;
	147	return;
	148	}
	149
	150	sd_hd_coeffs = &colorspace_coeffs[sel];
	151
	152	/* select between SD or HD coefficients */
	153	if (yuv_colorspace == V4L2_COLORSPACE_SMPTE170M)
	154	coeff = sd_hd_coeffs->sd;
	155	else
	156	coeff = sd_hd_coeffs->hd;
	157
	158	end_coeff = coeff + 12;
	159
	160	for (; coeff < end_coeff; coeff += 2)
	161	shadow_csc++ = ((coeff + 1) << 16) \| *coeff;
	162	}
	163
6948082d AT	164	struct csc_data csc_create(struct platform_device pdev)
	165	{
	166	struct csc_data *csc;
	167
	168	dev_dbg(&pdev->dev, "csc_create\n");
	169
	170	csc = devm_kzalloc(&pdev->dev, sizeof(*csc), GFP_KERNEL);
	171	if (!csc) {
	172	dev_err(&pdev->dev, "couldn't alloc csc_data\n");
	173	return ERR_PTR(-ENOMEM);
	174	}
	175
	176	csc->pdev = pdev;
	177
	178	csc->res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
536954f1	179	"csc");
6948082d AT	180	if (csc->res == NULL) {
	181	dev_err(&pdev->dev, "missing platform resources data\n");
	182	return ERR_PTR(-ENODEV);
	183	}
	184
	185	csc->base = devm_ioremap_resource(&pdev->dev, csc->res);
691903f9	186	if (IS_ERR(csc->base)) {
6948082d	187	dev_err(&pdev->dev, "failed to ioremap\n");
3f799135	188	return ERR_CAST(csc->base);
6948082d AT	189	}
	190
	191	return csc;
	192	}