[deliverable/linux.git] / drivers / media / platform / s5p-jpeg / jpeg-core.h

/* linux/drivers/media/platform/s5p-jpeg/jpeg-core.h
 *
 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
 *		http://www.samsung.com
 *
 * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.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.
 */

#ifndef JPEG_CORE_H_
#define JPEG_CORE_H_

#include <linux/interrupt.h>
#include <media/v4l2-device.h>
#include <media/v4l2-fh.h>
#include <media/v4l2-ctrls.h>

#define S5P_JPEG_M2M_NAME		"s5p-jpeg"

#define JPEG_MAX_CLOCKS			4

/* JPEG compression quality setting */
#define S5P_JPEG_COMPR_QUAL_BEST	0
#define S5P_JPEG_COMPR_QUAL_WORST	3

/* JPEG RGB to YCbCr conversion matrix coefficients */
#define S5P_JPEG_COEF11			0x4d
#define S5P_JPEG_COEF12			0x97
#define S5P_JPEG_COEF13			0x1e
#define S5P_JPEG_COEF21			0x2c
#define S5P_JPEG_COEF22			0x57
#define S5P_JPEG_COEF23			0x83
#define S5P_JPEG_COEF31			0x83
#define S5P_JPEG_COEF32			0x6e
#define S5P_JPEG_COEF33			0x13

#define EXYNOS3250_IRQ_TIMEOUT		0x10000000

/* a selection of JPEG markers */
#define TEM				0x01
#define SOF0				0xc0
#define DHT				0xc4
#define RST				0xd0
#define SOI				0xd8
#define EOI				0xd9
#define	SOS				0xda
#define DQT				0xdb
#define DHP				0xde

/* Flags that indicate a format can be used for capture/output */
#define SJPEG_FMT_FLAG_ENC_CAPTURE	(1 << 0)
#define SJPEG_FMT_FLAG_ENC_OUTPUT	(1 << 1)
#define SJPEG_FMT_FLAG_DEC_CAPTURE	(1 << 2)
#define SJPEG_FMT_FLAG_DEC_OUTPUT	(1 << 3)
#define SJPEG_FMT_FLAG_S5P		(1 << 4)
#define SJPEG_FMT_FLAG_EXYNOS3250	(1 << 5)
#define SJPEG_FMT_FLAG_EXYNOS4		(1 << 6)
#define SJPEG_FMT_RGB			(1 << 7)
#define SJPEG_FMT_NON_RGB		(1 << 8)

#define S5P_JPEG_ENCODE		0
#define S5P_JPEG_DECODE		1

#define FMT_TYPE_OUTPUT		0
#define FMT_TYPE_CAPTURE	1

#define SJPEG_SUBSAMPLING_444	0x11
#define SJPEG_SUBSAMPLING_422	0x21
#define SJPEG_SUBSAMPLING_420	0x22

#define S5P_JPEG_MAX_MARKER	4

/* Version numbers */
enum sjpeg_version {
	SJPEG_S5P,
	SJPEG_EXYNOS3250,
	SJPEG_EXYNOS4,
	SJPEG_EXYNOS5420,
	SJPEG_EXYNOS5433,
};

enum exynos4_jpeg_result {
	OK_ENC_OR_DEC,
	ERR_PROT,
	ERR_DEC_INVALID_FORMAT,
	ERR_MULTI_SCAN,
	ERR_FRAME,
	ERR_UNKNOWN,
};

enum  exynos4_jpeg_img_quality_level {
	QUALITY_LEVEL_1 = 0,	/* high */
	QUALITY_LEVEL_2,
	QUALITY_LEVEL_3,
	QUALITY_LEVEL_4,	/* low */
};

/**
 * struct s5p_jpeg - JPEG IP abstraction
 * @lock:		the mutex protecting this structure
 * @slock:		spinlock protecting the device contexts
 * @v4l2_dev:		v4l2 device for mem2mem mode
 * @vfd_encoder:	video device node for encoder mem2mem mode
 * @vfd_decoder:	video device node for decoder mem2mem mode
 * @m2m_dev:		v4l2 mem2mem device data
 * @regs:		JPEG IP registers mapping
 * @irq:		JPEG IP irq
 * @clocks:		JPEG IP clock(s)
 * @dev:		JPEG IP struct device
 * @variant:		driver variant to be used
 * @irq_status		interrupt flags set during single encode/decode
			operation

 */
struct s5p_jpeg {
	struct mutex		lock;
	spinlock_t		slock;

	struct v4l2_device	v4l2_dev;
	struct video_device	*vfd_encoder;
	struct video_device	*vfd_decoder;
	struct v4l2_m2m_dev	*m2m_dev;

	void __iomem		*regs;
	unsigned int		irq;
	enum exynos4_jpeg_result irq_ret;
	struct clk		*clocks[JPEG_MAX_CLOCKS];
	struct device		*dev;
	struct s5p_jpeg_variant *variant;
	u32			irq_status;
};

struct s5p_jpeg_variant {
	unsigned int		version;
	unsigned int		fmt_ver_flag;
	unsigned int		hw3250_compat:1;
	unsigned int		htbl_reinit:1;
	unsigned int		hw_ex4_compat:1;
	struct v4l2_m2m_ops	*m2m_ops;
	irqreturn_t		(*jpeg_irq)(int irq, void *priv);
	const char		*clk_names[JPEG_MAX_CLOCKS];
	int			num_clocks;
};

/**
 * struct jpeg_fmt - driver's internal color format data
 * @name:	format descritpion
 * @fourcc:	the fourcc code, 0 if not applicable
 * @depth:	number of bits per pixel
 * @colplanes:	number of color planes (1 for packed formats)
 * @h_align:	horizontal alignment order (align to 2^h_align)
 * @v_align:	vertical alignment order (align to 2^v_align)
 * @flags:	flags describing format applicability
 */
struct s5p_jpeg_fmt {
	char	*name;
	u32	fourcc;
	int	depth;
	int	colplanes;
	int	memplanes;
	int	h_align;
	int	v_align;
	int	subsampling;
	u32	flags;
};

/**
 * s5p_jpeg_marker - collection of markers from jpeg header
 * @marker:	markers' positions relative to the buffer beginning
 * @len:	markers' payload lengths (without length field)
 * @n:		number of markers in collection
 */
struct s5p_jpeg_marker {
	u32	marker[S5P_JPEG_MAX_MARKER];
	u32	len[S5P_JPEG_MAX_MARKER];
	u32	n;
};

/**
 * s5p_jpeg_q_data - parameters of one queue
 * @fmt:	driver-specific format of this queue
 * @w:		image width
 * @h:		image height
 * @sos:	SOS marker's position relative to the buffer beginning
 * @dht:	DHT markers' positions relative to the buffer beginning
 * @dqt:	DQT markers' positions relative to the buffer beginning
 * @sof:	SOF0 marker's postition relative to the buffer beginning
 * @sof_len:	SOF0 marker's payload length (without length field itself)
 * @components:	number of image components
 * @size:	image buffer size in bytes
 */
struct s5p_jpeg_q_data {
	struct s5p_jpeg_fmt	*fmt;
	u32			w;
	u32			h;
	u32			sos;
	struct s5p_jpeg_marker	dht;
	struct s5p_jpeg_marker	dqt;
	u32			sof;
	u32			sof_len;
	u32			components;
	u32			size;
};

/**
 * s5p_jpeg_ctx - the device context data
 * @jpeg:		JPEG IP device for this context
 * @mode:		compression (encode) operation or decompression (decode)
 * @compr_quality:	destination image quality in compression (encode) mode
 * @restart_interval:	JPEG restart interval for JPEG encoding
 * @subsampling:	subsampling of a raw format or a JPEG
 * @out_q:		source (output) queue information
 * @cap_q:		destination (capture) queue queue information
 * @scale_factor:	scale factor for JPEG decoding
 * @crop_rect:		a rectangle representing crop area of the output buffer
 * @fh:			V4L2 file handle
 * @hdr_parsed:		set if header has been parsed during decompression
 * @crop_altered:	set if crop rectangle has been altered by the user space
 * @ctrl_handler:	controls handler
 */
struct s5p_jpeg_ctx {
	struct s5p_jpeg		*jpeg;
	unsigned int		mode;
	unsigned short		compr_quality;
	unsigned short		restart_interval;
	unsigned short		subsampling;
	struct s5p_jpeg_q_data	out_q;
	struct s5p_jpeg_q_data	cap_q;
	unsigned int		scale_factor;
	struct v4l2_rect	crop_rect;
	struct v4l2_fh		fh;
	bool			hdr_parsed;
	bool			crop_altered;
	struct v4l2_ctrl_handler ctrl_handler;
};

/**
 * s5p_jpeg_buffer - description of memory containing input JPEG data
 * @size:	buffer size
 * @curr:	current position in the buffer
 * @data:	pointer to the data
 */
struct s5p_jpeg_buffer {
	unsigned long size;
	unsigned long curr;
	unsigned long data;
};

/**
 * struct s5p_jpeg_addr - JPEG converter physical address set for DMA
 * @y:   luminance plane physical address
 * @cb:  Cb plane physical address
 * @cr:  Cr plane physical address
 */
struct s5p_jpeg_addr {
	u32     y;
	u32     cb;
	u32     cr;
};

#endif /* JPEG_CORE_H */
Commit	Line	Data
2c3fb08b	1	/* linux/drivers/media/platform/s5p-jpeg/jpeg-core.h
bb677f3a AP	2	*
	3	* Copyright (c) 2011 Samsung Electronics Co., Ltd.
	4	* http://www.samsung.com
	5	*
	6	* Author: Andrzej Pietrasiewicz <andrzej.p@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 version 2 as
	10	* published by the Free Software Foundation.
	11	*/
	12
	13	#ifndef JPEG_CORE_H_
	14	#define JPEG_CORE_H_
	15
80529ae5	16	#include <linux/interrupt.h>
bb677f3a	17	#include <media/v4l2-device.h>
275de24d	18	#include <media/v4l2-fh.h>
15f4bc3b	19	#include <media/v4l2-ctrls.h>
bb677f3a AP	20
	21	#define S5P_JPEG_M2M_NAME "s5p-jpeg"
	22
b95a24d6 MS	23	#define JPEG_MAX_CLOCKS 4
b95a24d6 MS	24
bb677f3a AP	25	/* JPEG compression quality setting */
	26	#define S5P_JPEG_COMPR_QUAL_BEST 0
	27	#define S5P_JPEG_COMPR_QUAL_WORST 3
	28
	29	/* JPEG RGB to YCbCr conversion matrix coefficients */
	30	#define S5P_JPEG_COEF11 0x4d
	31	#define S5P_JPEG_COEF12 0x97
	32	#define S5P_JPEG_COEF13 0x1e
	33	#define S5P_JPEG_COEF21 0x2c
	34	#define S5P_JPEG_COEF22 0x57
	35	#define S5P_JPEG_COEF23 0x83
	36	#define S5P_JPEG_COEF31 0x83
	37	#define S5P_JPEG_COEF32 0x6e
	38	#define S5P_JPEG_COEF33 0x13
	39
3246fdaa JA	40	#define EXYNOS3250_IRQ_TIMEOUT 0x10000000
3246fdaa JA	41
bb677f3a AP	42	/* a selection of JPEG markers */
	43	#define TEM 0x01
	44	#define SOF0 0xc0
6c96dbbc	45	#define DHT 0xc4
bb677f3a AP	46	#define RST 0xd0
	47	#define SOI 0xd8
	48	#define EOI 0xd9
6c96dbbc AP	49	#define SOS 0xda
6c96dbbc AP	50	#define DQT 0xdb
bb677f3a AP	51	#define DHP 0xde
bb677f3a AP	52
80529ae5 JA	53	/* Flags that indicate a format can be used for capture/output */
	54	#define SJPEG_FMT_FLAG_ENC_CAPTURE (1 << 0)
	55	#define SJPEG_FMT_FLAG_ENC_OUTPUT (1 << 1)
	56	#define SJPEG_FMT_FLAG_DEC_CAPTURE (1 << 2)
	57	#define SJPEG_FMT_FLAG_DEC_OUTPUT (1 << 3)
	58	#define SJPEG_FMT_FLAG_S5P (1 << 4)
3246fdaa JA	59	#define SJPEG_FMT_FLAG_EXYNOS3250 (1 << 5)
	60	#define SJPEG_FMT_FLAG_EXYNOS4 (1 << 6)
	61	#define SJPEG_FMT_RGB (1 << 7)
	62	#define SJPEG_FMT_NON_RGB (1 << 8)
80529ae5	63
9f7b62d9 JA	64	#define S5P_JPEG_ENCODE 0
	65	#define S5P_JPEG_DECODE 1
	66
80529ae5 JA	67	#define FMT_TYPE_OUTPUT 0
	68	#define FMT_TYPE_CAPTURE 1
	69
	70	#define SJPEG_SUBSAMPLING_444 0x11
	71	#define SJPEG_SUBSAMPLING_422 0x21
	72	#define SJPEG_SUBSAMPLING_420 0x22
bb677f3a	73
6c96dbbc AP	74	#define S5P_JPEG_MAX_MARKER 4
6c96dbbc AP	75
80529ae5	76	/* Version numbers */
7c15fd4b AP	77	enum sjpeg_version {
	78	SJPEG_S5P,
	79	SJPEG_EXYNOS3250,
	80	SJPEG_EXYNOS4,
	81	SJPEG_EXYNOS5420,
6c96dbbc	82	SJPEG_EXYNOS5433,
7c15fd4b	83	};
80529ae5 JA	84
	85	enum exynos4_jpeg_result {
	86	OK_ENC_OR_DEC,
	87	ERR_PROT,
	88	ERR_DEC_INVALID_FORMAT,
	89	ERR_MULTI_SCAN,
	90	ERR_FRAME,
	91	ERR_UNKNOWN,
	92	};
9f7b62d9	93
80529ae5 JA	94	enum exynos4_jpeg_img_quality_level {
	95	QUALITY_LEVEL_1 = 0, /* high */
	96	QUALITY_LEVEL_2,
	97	QUALITY_LEVEL_3,
	98	QUALITY_LEVEL_4, /* low */
	99	};
9f7b62d9	100
bb677f3a AP	101	/**
	102	* struct s5p_jpeg - JPEG IP abstraction
	103	* @lock: the mutex protecting this structure
15f4bc3b	104	* @slock: spinlock protecting the device contexts
bb677f3a AP	105	* @v4l2_dev: v4l2 device for mem2mem mode
	106	* @vfd_encoder: video device node for encoder mem2mem mode
	107	* @vfd_decoder: video device node for decoder mem2mem mode
	108	* @m2m_dev: v4l2 mem2mem device data
bb677f3a AP	109	* @regs: JPEG IP registers mapping
bb677f3a AP	110	* @irq: JPEG IP irq
b95a24d6	111	* @clocks: JPEG IP clock(s)
bb677f3a	112	* @dev: JPEG IP struct device
3246fdaa JA	113	* @variant: driver variant to be used
	114	* @irq_status interrupt flags set during single encode/decode
	115	operation
	116
bb677f3a AP	117	*/
	118	struct s5p_jpeg {
	119	struct mutex lock;
a75831f3	120	spinlock_t slock;
bb677f3a AP	121
	122	struct v4l2_device v4l2_dev;
	123	struct video_device *vfd_encoder;
	124	struct video_device *vfd_decoder;
	125	struct v4l2_m2m_dev *m2m_dev;
	126
bb677f3a AP	127	void __iomem *regs;
bb677f3a AP	128	unsigned int irq;
80529ae5	129	enum exynos4_jpeg_result irq_ret;
b95a24d6	130	struct clk *clocks[JPEG_MAX_CLOCKS];
bb677f3a	131	struct device *dev;
80529ae5	132	struct s5p_jpeg_variant *variant;
3246fdaa	133	u32 irq_status;
80529ae5 JA	134	};
	135
	136	struct s5p_jpeg_variant {
bf689bb8 JA	137	unsigned int version;
bf689bb8 JA	138	unsigned int fmt_ver_flag;
7c15fd4b AP	139	unsigned int hw3250_compat:1;
7c15fd4b AP	140	unsigned int htbl_reinit:1;
6c96dbbc	141	unsigned int hw_ex4_compat:1;
bf689bb8 JA	142	struct v4l2_m2m_ops *m2m_ops;
bf689bb8 JA	143	irqreturn_t (jpeg_irq)(int irq, void priv);
b95a24d6 MS	144	const char *clk_names[JPEG_MAX_CLOCKS];
b95a24d6 MS	145	int num_clocks;
bb677f3a AP	146	};
	147
	148	/**
	149	* struct jpeg_fmt - driver's internal color format data
	150	* @name: format descritpion
	151	* @fourcc: the fourcc code, 0 if not applicable
	152	* @depth: number of bits per pixel
	153	* @colplanes: number of color planes (1 for packed formats)
	154	* @h_align: horizontal alignment order (align to 2^h_align)
	155	* @v_align: vertical alignment order (align to 2^v_align)
80529ae5	156	* @flags: flags describing format applicability
bb677f3a AP	157	*/
	158	struct s5p_jpeg_fmt {
	159	char *name;
	160	u32 fourcc;
	161	int depth;
	162	int colplanes;
80529ae5	163	int memplanes;
bb677f3a AP	164	int h_align;
bb677f3a AP	165	int v_align;
80529ae5 JA	166	int subsampling;
80529ae5 JA	167	u32 flags;
bb677f3a AP	168	};
bb677f3a AP	169
6c96dbbc AP	170	/**
	171	* s5p_jpeg_marker - collection of markers from jpeg header
	172	* @marker: markers' positions relative to the buffer beginning
	173	* @len: markers' payload lengths (without length field)
	174	* @n: number of markers in collection
	175	*/
	176	struct s5p_jpeg_marker {
	177	u32 marker[S5P_JPEG_MAX_MARKER];
	178	u32 len[S5P_JPEG_MAX_MARKER];
	179	u32 n;
	180	};
	181
bb677f3a AP	182	/**
	183	* s5p_jpeg_q_data - parameters of one queue
	184	* @fmt: driver-specific format of this queue
	185	* @w: image width
	186	* @h: image height
6c96dbbc AP	187	* @sos: SOS marker's position relative to the buffer beginning
	188	* @dht: DHT markers' positions relative to the buffer beginning
	189	* @dqt: DQT markers' positions relative to the buffer beginning
	190	* @sof: SOF0 marker's postition relative to the buffer beginning
	191	* @sof_len: SOF0 marker's payload length (without length field itself)
	192	* @components: number of image components
bb677f3a AP	193	* @size: image buffer size in bytes
	194	*/
	195	struct s5p_jpeg_q_data {
	196	struct s5p_jpeg_fmt *fmt;
	197	u32 w;
	198	u32 h;
6c96dbbc AP	199	u32 sos;
	200	struct s5p_jpeg_marker dht;
	201	struct s5p_jpeg_marker dqt;
	202	u32 sof;
	203	u32 sof_len;
	204	u32 components;
bb677f3a AP	205	u32 size;
	206	};
	207
	208	/**
	209	* s5p_jpeg_ctx - the device context data
	210	* @jpeg: JPEG IP device for this context
	211	* @mode: compression (encode) operation or decompression (decode)
	212	* @compr_quality: destination image quality in compression (encode) mode
3246fdaa JA	213	* @restart_interval: JPEG restart interval for JPEG encoding
3246fdaa JA	214	* @subsampling: subsampling of a raw format or a JPEG
bb677f3a	215	* @out_q: source (output) queue information
3246fdaa JA	216	* @cap_q: destination (capture) queue queue information
	217	* @scale_factor: scale factor for JPEG decoding
	218	* @crop_rect: a rectangle representing crop area of the output buffer
	219	* @fh: V4L2 file handle
bb677f3a	220	* @hdr_parsed: set if header has been parsed during decompression
3246fdaa	221	* @crop_altered: set if crop rectangle has been altered by the user space
15f4bc3b	222	* @ctrl_handler: controls handler
bb677f3a AP	223	*/
	224	struct s5p_jpeg_ctx {
	225	struct s5p_jpeg *jpeg;
	226	unsigned int mode;
15f4bc3b SN	227	unsigned short compr_quality;
	228	unsigned short restart_interval;
	229	unsigned short subsampling;
bb677f3a AP	230	struct s5p_jpeg_q_data out_q;
bb677f3a AP	231	struct s5p_jpeg_q_data cap_q;
3246fdaa JA	232	unsigned int scale_factor;
3246fdaa JA	233	struct v4l2_rect crop_rect;
275de24d	234	struct v4l2_fh fh;
bb677f3a	235	bool hdr_parsed;
3246fdaa	236	bool crop_altered;
15f4bc3b	237	struct v4l2_ctrl_handler ctrl_handler;
bb677f3a AP	238	};
	239
	240	/**
	241	* s5p_jpeg_buffer - description of memory containing input JPEG data
	242	* @size: buffer size
	243	* @curr: current position in the buffer
	244	* @data: pointer to the data
	245	*/
	246	struct s5p_jpeg_buffer {
	247	unsigned long size;
	248	unsigned long curr;
	249	unsigned long data;
	250	};
	251
80529ae5 JA	252	/**
	253	* struct s5p_jpeg_addr - JPEG converter physical address set for DMA
	254	* @y: luminance plane physical address
	255	* @cb: Cb plane physical address
	256	* @cr: Cr plane physical address
	257	*/
	258	struct s5p_jpeg_addr {
	259	u32 y;
	260	u32 cb;
	261	u32 cr;
	262	};
	263
bb677f3a	264	#endif /* JPEG_CORE_H */