[mirror_ubuntu-hirsute-kernel.git] / drivers / media / platform / coda / coda.h

/*
 * Coda multi-standard codec IP
 *
 * Copyright (C) 2012 Vista Silicon S.L.
 *    Javier Martin, <javier.martin@vista-silicon.com>
 *    Xavier Duret
 * Copyright (C) 2012-2014 Philipp Zabel, Pengutronix
 *
 * 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.
 */

#ifndef __CODA_H__
#define __CODA_H__

#include <linux/debugfs.h>
#include <linux/irqreturn.h>
#include <linux/mutex.h>
#include <linux/kfifo.h>
#include <linux/videodev2.h>

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

#include "coda_regs.h"

#define CODA_MAX_FRAMEBUFFERS	8
#define FMO_SLICE_SAVE_BUF_SIZE	(32)

enum {
	V4L2_M2M_SRC = 0,
	V4L2_M2M_DST = 1,
};

enum coda_inst_type {
	CODA_INST_ENCODER,
	CODA_INST_DECODER,
};

enum coda_product {
	CODA_DX6 = 0xf001,
	CODA_7541 = 0xf012,
	CODA_960 = 0xf020,
};

struct coda_video_device;

struct coda_devtype {
	char			*firmware[3];
	enum coda_product	product;
	const struct coda_codec	*codecs;
	unsigned int		num_codecs;
	const struct coda_video_device **vdevs;
	unsigned int		num_vdevs;
	size_t			workbuf_size;
	size_t			tempbuf_size;
	size_t			iram_size;
};

struct coda_aux_buf {
	void			*vaddr;
	dma_addr_t		paddr;
	u32			size;
	struct debugfs_blob_wrapper blob;
	struct dentry		*dentry;
};

struct coda_dev {
	struct v4l2_device	v4l2_dev;
	struct video_device	vfd[5];
	struct platform_device	*plat_dev;
	const struct coda_devtype *devtype;
	int			firmware;
	struct vdoa_data	*vdoa;

	void __iomem		*regs_base;
	struct clk		*clk_per;
	struct clk		*clk_ahb;
	struct reset_control	*rstc;

	struct coda_aux_buf	codebuf;
	struct coda_aux_buf	tempbuf;
	struct coda_aux_buf	workbuf;
	struct gen_pool		*iram_pool;
	struct coda_aux_buf	iram;

	spinlock_t		irqlock;
	struct mutex		dev_mutex;
	struct mutex		coda_mutex;
	struct workqueue_struct	*workqueue;
	struct v4l2_m2m_dev	*m2m_dev;
	struct list_head	instances;
	unsigned long		instance_mask;
	struct dentry		*debugfs_root;
};

struct coda_codec {
	u32 mode;
	u32 src_fourcc;
	u32 dst_fourcc;
	u32 max_w;
	u32 max_h;
};

struct coda_huff_tab;

struct coda_params {
	u8			rot_mode;
	u8			h264_intra_qp;
	u8			h264_inter_qp;
	u8			h264_min_qp;
	u8			h264_max_qp;
	u8			h264_deblk_enabled;
	u8			h264_deblk_alpha;
	u8			h264_deblk_beta;
	u8			mpeg4_intra_qp;
	u8			mpeg4_inter_qp;
	u8			gop_size;
	int			intra_refresh;
	u8			jpeg_quality;
	u8			jpeg_restart_interval;
	u8			*jpeg_qmat_tab[3];
	int			codec_mode;
	int			codec_mode_aux;
	enum v4l2_mpeg_video_multi_slice_mode slice_mode;
	u32			framerate;
	u16			bitrate;
	u16			vbv_delay;
	u32			vbv_size;
	u32			slice_max_bits;
	u32			slice_max_mb;
};

struct coda_buffer_meta {
	struct list_head	list;
	u32			sequence;
	struct v4l2_timecode	timecode;
	u64			timestamp;
	u32			start;
	u32			end;
};

/* Per-queue, driver-specific private data */
struct coda_q_data {
	unsigned int		width;
	unsigned int		height;
	unsigned int		bytesperline;
	unsigned int		sizeimage;
	unsigned int		fourcc;
	struct v4l2_rect	rect;
};

struct coda_iram_info {
	u32		axi_sram_use;
	phys_addr_t	buf_bit_use;
	phys_addr_t	buf_ip_ac_dc_use;
	phys_addr_t	buf_dbk_y_use;
	phys_addr_t	buf_dbk_c_use;
	phys_addr_t	buf_ovl_use;
	phys_addr_t	buf_btp_use;
	phys_addr_t	search_ram_paddr;
	int		search_ram_size;
	int		remaining;
	phys_addr_t	next_paddr;
};

#define GDI_LINEAR_FRAME_MAP 0
#define GDI_TILED_FRAME_MB_RASTER_MAP 1

struct coda_ctx;

struct coda_context_ops {
	int (*queue_init)(void *priv, struct vb2_queue *src_vq,
			  struct vb2_queue *dst_vq);
	int (*reqbufs)(struct coda_ctx *ctx, struct v4l2_requestbuffers *rb);
	int (*start_streaming)(struct coda_ctx *ctx);
	int (*prepare_run)(struct coda_ctx *ctx);
	void (*finish_run)(struct coda_ctx *ctx);
	void (*seq_end_work)(struct work_struct *work);
	void (*release)(struct coda_ctx *ctx);
};

struct coda_ctx {
	struct coda_dev			*dev;
	struct mutex			buffer_mutex;
	struct list_head		list;
	struct work_struct		pic_run_work;
	struct work_struct		seq_end_work;
	struct completion		completion;
	const struct coda_video_device	*cvd;
	const struct coda_context_ops	*ops;
	int				aborting;
	int				initialized;
	int				streamon_out;
	int				streamon_cap;
	u32				qsequence;
	u32				osequence;
	u32				sequence_offset;
	struct coda_q_data		q_data[2];
	enum coda_inst_type		inst_type;
	const struct coda_codec		*codec;
	enum v4l2_colorspace		colorspace;
	struct coda_params		params;
	struct v4l2_ctrl_handler	ctrls;
	struct v4l2_fh			fh;
	int				gopcounter;
	int				runcounter;
	char				vpu_header[3][64];
	int				vpu_header_size[3];
	struct kfifo			bitstream_fifo;
	struct mutex			bitstream_mutex;
	struct coda_aux_buf		bitstream;
	bool				hold;
	struct coda_aux_buf		parabuf;
	struct coda_aux_buf		psbuf;
	struct coda_aux_buf		slicebuf;
	struct coda_aux_buf		internal_frames[CODA_MAX_FRAMEBUFFERS];
	u32				frame_types[CODA_MAX_FRAMEBUFFERS];
	struct coda_buffer_meta		frame_metas[CODA_MAX_FRAMEBUFFERS];
	u32				frame_errors[CODA_MAX_FRAMEBUFFERS];
	struct list_head		buffer_meta_list;
	spinlock_t			buffer_meta_lock;
	int				num_metas;
	struct coda_aux_buf		workbuf;
	int				num_internal_frames;
	int				idx;
	int				reg_idx;
	struct coda_iram_info		iram_info;
	int				tiled_map_type;
	u32				bit_stream_param;
	u32				frm_dis_flg;
	u32				frame_mem_ctrl;
	int				display_idx;
	struct dentry			*debugfs_entry;
	bool				use_bit;
	bool				use_vdoa;
	struct vdoa_ctx			*vdoa;
};

extern int coda_debug;

void coda_write(struct coda_dev *dev, u32 data, u32 reg);
unsigned int coda_read(struct coda_dev *dev, u32 reg);
void coda_write_base(struct coda_ctx *ctx, struct coda_q_data *q_data,
		     struct vb2_v4l2_buffer *buf, unsigned int reg_y);

int coda_alloc_aux_buf(struct coda_dev *dev, struct coda_aux_buf *buf,
		       size_t size, const char *name, struct dentry *parent);
void coda_free_aux_buf(struct coda_dev *dev, struct coda_aux_buf *buf);

int coda_encoder_queue_init(void *priv, struct vb2_queue *src_vq,
			    struct vb2_queue *dst_vq);
int coda_decoder_queue_init(void *priv, struct vb2_queue *src_vq,
			    struct vb2_queue *dst_vq);

int coda_hw_reset(struct coda_ctx *ctx);

void coda_fill_bitstream(struct coda_ctx *ctx, bool streaming);

void coda_set_gdi_regs(struct coda_ctx *ctx);

static inline struct coda_q_data *get_q_data(struct coda_ctx *ctx,
					     enum v4l2_buf_type type)
{
	switch (type) {
	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
		return &(ctx->q_data[V4L2_M2M_SRC]);
	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
		return &(ctx->q_data[V4L2_M2M_DST]);
	default:
		return NULL;
	}
}

const char *coda_product_name(int product);

int coda_check_firmware(struct coda_dev *dev);

static inline unsigned int coda_get_bitstream_payload(struct coda_ctx *ctx)
{
	return kfifo_len(&ctx->bitstream_fifo);
}

void coda_bit_stream_end_flag(struct coda_ctx *ctx);

void coda_m2m_buf_done(struct coda_ctx *ctx, struct vb2_v4l2_buffer *buf,
		       enum vb2_buffer_state state);

int coda_h264_padding(int size, char *p);

bool coda_jpeg_check_buffer(struct coda_ctx *ctx, struct vb2_buffer *vb);
int coda_jpeg_write_tables(struct coda_ctx *ctx);
void coda_set_jpeg_compression_quality(struct coda_ctx *ctx, int quality);

extern const struct coda_context_ops coda_bit_encode_ops;
extern const struct coda_context_ops coda_bit_decode_ops;

irqreturn_t coda_irq_handler(int irq, void *data);

#endif /* __CODA_H__ */
Commit	Line	Data
a2b3e46a PZ	1	/*
	2	* Coda multi-standard codec IP
	3	*
	4	* Copyright (C) 2012 Vista Silicon S.L.
	5	* Javier Martin, <javier.martin@vista-silicon.com>
	6	* Xavier Duret
	7	* Copyright (C) 2012-2014 Philipp Zabel, Pengutronix
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*/
	14
9a1a8f99 PZ	15	#ifndef __CODA_H__
	16	#define __CODA_H__
	17
a2b3e46a PZ	18	#include <linux/debugfs.h>
	19	#include <linux/irqreturn.h>
	20	#include <linux/mutex.h>
	21	#include <linux/kfifo.h>
	22	#include <linux/videodev2.h>
	23
	24	#include <media/v4l2-ctrls.h>
	25	#include <media/v4l2-device.h>
	26	#include <media/v4l2-fh.h>
c139990e	27	#include <media/videobuf2-v4l2.h>
a2b3e46a PZ	28
	29	#include "coda_regs.h"
	30
	31	#define CODA_MAX_FRAMEBUFFERS 8
a2b3e46a PZ	32	#define FMO_SLICE_SAVE_BUF_SIZE (32)
	33
	34	enum {
	35	V4L2_M2M_SRC = 0,
	36	V4L2_M2M_DST = 1,
	37	};
	38
	39	enum coda_inst_type {
	40	CODA_INST_ENCODER,
	41	CODA_INST_DECODER,
	42	};
	43
	44	enum coda_product {
	45	CODA_DX6 = 0xf001,
	46	CODA_7541 = 0xf012,
	47	CODA_960 = 0xf020,
	48	};
	49
2c11d1bd PZ	50	struct coda_video_device;
2c11d1bd PZ	51
a2b3e46a	52	struct coda_devtype {
8af7779f	53	char *firmware[3];
a2b3e46a PZ	54	enum coda_product product;
	55	const struct coda_codec *codecs;
	56	unsigned int num_codecs;
2c11d1bd PZ	57	const struct coda_video_device **vdevs;
2c11d1bd PZ	58	unsigned int num_vdevs;
a2b3e46a PZ	59	size_t workbuf_size;
	60	size_t tempbuf_size;
	61	size_t iram_size;
	62	};
	63
	64	struct coda_aux_buf {
	65	void *vaddr;
	66	dma_addr_t paddr;
	67	u32 size;
	68	struct debugfs_blob_wrapper blob;
	69	struct dentry *dentry;
	70	};
	71
	72	struct coda_dev {
	73	struct v4l2_device v4l2_dev;
cb1d3a33	74	struct video_device vfd[5];
a2b3e46a PZ	75	struct platform_device *plat_dev;
a2b3e46a PZ	76	const struct coda_devtype *devtype;
2ac7f08e	77	int firmware;
e7f3c548	78	struct vdoa_data *vdoa;
a2b3e46a PZ	79
	80	void __iomem *regs_base;
	81	struct clk *clk_per;
	82	struct clk *clk_ahb;
	83	struct reset_control *rstc;
	84
	85	struct coda_aux_buf codebuf;
	86	struct coda_aux_buf tempbuf;
	87	struct coda_aux_buf workbuf;
	88	struct gen_pool *iram_pool;
	89	struct coda_aux_buf iram;
	90
	91	spinlock_t irqlock;
	92	struct mutex dev_mutex;
	93	struct mutex coda_mutex;
	94	struct workqueue_struct *workqueue;
	95	struct v4l2_m2m_dev *m2m_dev;
a2b3e46a PZ	96	struct list_head instances;
	97	unsigned long instance_mask;
	98	struct dentry *debugfs_root;
	99	};
	100
	101	struct coda_codec {
	102	u32 mode;
	103	u32 src_fourcc;
	104	u32 dst_fourcc;
	105	u32 max_w;
	106	u32 max_h;
	107	};
	108
	109	struct coda_huff_tab;
	110
	111	struct coda_params {
	112	u8 rot_mode;
	113	u8 h264_intra_qp;
	114	u8 h264_inter_qp;
	115	u8 h264_min_qp;
	116	u8 h264_max_qp;
	117	u8 h264_deblk_enabled;
	118	u8 h264_deblk_alpha;
	119	u8 h264_deblk_beta;
	120	u8 mpeg4_intra_qp;
	121	u8 mpeg4_inter_qp;
	122	u8 gop_size;
	123	int intra_refresh;
cb1d3a33 PZ	124	u8 jpeg_quality;
	125	u8 jpeg_restart_interval;
	126	u8 *jpeg_qmat_tab[3];
a2b3e46a PZ	127	int codec_mode;
	128	int codec_mode_aux;
	129	enum v4l2_mpeg_video_multi_slice_mode slice_mode;
	130	u32 framerate;
	131	u16 bitrate;
da2b3b3e PZ	132	u16 vbv_delay;
da2b3b3e PZ	133	u32 vbv_size;
a2b3e46a PZ	134	u32 slice_max_bits;
	135	u32 slice_max_mb;
	136	};
	137
7cbb105f	138	struct coda_buffer_meta {
a2b3e46a PZ	139	struct list_head list;
	140	u32 sequence;
	141	struct v4l2_timecode timecode;
d6dd645e	142	u64 timestamp;
7cbb105f PZ	143	u32 start;
7cbb105f PZ	144	u32 end;
a2b3e46a PZ	145	};
	146
	147	/* Per-queue, driver-specific private data */
	148	struct coda_q_data {
	149	unsigned int width;
	150	unsigned int height;
	151	unsigned int bytesperline;
	152	unsigned int sizeimage;
	153	unsigned int fourcc;
	154	struct v4l2_rect rect;
	155	};
	156
	157	struct coda_iram_info {
	158	u32 axi_sram_use;
	159	phys_addr_t buf_bit_use;
	160	phys_addr_t buf_ip_ac_dc_use;
	161	phys_addr_t buf_dbk_y_use;
	162	phys_addr_t buf_dbk_c_use;
	163	phys_addr_t buf_ovl_use;
	164	phys_addr_t buf_btp_use;
	165	phys_addr_t search_ram_paddr;
	166	int search_ram_size;
	167	int remaining;
	168	phys_addr_t next_paddr;
	169	};
	170
a2b3e46a	171	#define GDI_LINEAR_FRAME_MAP 0
a269e53b	172	#define GDI_TILED_FRAME_MB_RASTER_MAP 1
a2b3e46a	173
a1192a17 PZ	174	struct coda_ctx;
	175
	176	struct coda_context_ops {
	177	int (queue_init)(void priv, struct vb2_queue *src_vq,
	178	struct vb2_queue *dst_vq);
73751da6	179	int (reqbufs)(struct coda_ctx ctx, struct v4l2_requestbuffers *rb);
a1192a17 PZ	180	int (start_streaming)(struct coda_ctx ctx);
	181	int (prepare_run)(struct coda_ctx ctx);
	182	void (finish_run)(struct coda_ctx ctx);
	183	void (seq_end_work)(struct work_struct work);
	184	void (release)(struct coda_ctx ctx);
	185	};
	186
a2b3e46a PZ	187	struct coda_ctx {
	188	struct coda_dev *dev;
	189	struct mutex buffer_mutex;
	190	struct list_head list;
	191	struct work_struct pic_run_work;
	192	struct work_struct seq_end_work;
	193	struct completion completion;
2c11d1bd	194	const struct coda_video_device *cvd;
a1192a17	195	const struct coda_context_ops *ops;
a2b3e46a PZ	196	int aborting;
	197	int initialized;
	198	int streamon_out;
	199	int streamon_cap;
a2b3e46a PZ	200	u32 qsequence;
	201	u32 osequence;
	202	u32 sequence_offset;
	203	struct coda_q_data q_data[2];
	204	enum coda_inst_type inst_type;
	205	const struct coda_codec *codec;
	206	enum v4l2_colorspace colorspace;
	207	struct coda_params params;
	208	struct v4l2_ctrl_handler ctrls;
	209	struct v4l2_fh fh;
	210	int gopcounter;
	211	int runcounter;
	212	char vpu_header[3][64];
	213	int vpu_header_size[3];
	214	struct kfifo bitstream_fifo;
	215	struct mutex bitstream_mutex;
	216	struct coda_aux_buf bitstream;
	217	bool hold;
	218	struct coda_aux_buf parabuf;
	219	struct coda_aux_buf psbuf;
	220	struct coda_aux_buf slicebuf;
	221	struct coda_aux_buf internal_frames[CODA_MAX_FRAMEBUFFERS];
	222	u32 frame_types[CODA_MAX_FRAMEBUFFERS];
7cbb105f	223	struct coda_buffer_meta frame_metas[CODA_MAX_FRAMEBUFFERS];
a2b3e46a	224	u32 frame_errors[CODA_MAX_FRAMEBUFFERS];
7cbb105f	225	struct list_head buffer_meta_list;
47f3fa63 PZ	226	spinlock_t buffer_meta_lock;
47f3fa63 PZ	227	int num_metas;
a2b3e46a PZ	228	struct coda_aux_buf workbuf;
	229	int num_internal_frames;
	230	int idx;
	231	int reg_idx;
	232	struct coda_iram_info iram_info;
a269e53b	233	int tiled_map_type;
a2b3e46a PZ	234	u32 bit_stream_param;
	235	u32 frm_dis_flg;
	236	u32 frame_mem_ctrl;
	237	int display_idx;
	238	struct dentry *debugfs_entry;
a22496c6	239	bool use_bit;
e7f3c548 MT	240	bool use_vdoa;
e7f3c548 MT	241	struct vdoa_ctx *vdoa;
a2b3e46a	242	};
4f4ee9ee	243
79924ca9 PZ	244	extern int coda_debug;
	245
	246	void coda_write(struct coda_dev *dev, u32 data, u32 reg);
	247	unsigned int coda_read(struct coda_dev *dev, u32 reg);
856d7d93	248	void coda_write_base(struct coda_ctx ctx, struct coda_q_data q_data,
2d700715	249	struct vb2_v4l2_buffer *buf, unsigned int reg_y);
79924ca9 PZ	250
	251	int coda_alloc_aux_buf(struct coda_dev dev, struct coda_aux_buf buf,
	252	size_t size, const char name, struct dentry parent);
	253	void coda_free_aux_buf(struct coda_dev dev, struct coda_aux_buf buf);
	254
79924ca9 PZ	255	int coda_encoder_queue_init(void priv, struct vb2_queue src_vq,
	256	struct vb2_queue *dst_vq);
	257	int coda_decoder_queue_init(void priv, struct vb2_queue src_vq,
	258	struct vb2_queue *dst_vq);
	259
	260	int coda_hw_reset(struct coda_ctx *ctx);
	261
582d8872	262	void coda_fill_bitstream(struct coda_ctx *ctx, bool streaming);
79924ca9 PZ	263
	264	void coda_set_gdi_regs(struct coda_ctx *ctx);
	265
	266	static inline struct coda_q_data get_q_data(struct coda_ctx ctx,
	267	enum v4l2_buf_type type)
	268	{
	269	switch (type) {
	270	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
	271	return &(ctx->q_data[V4L2_M2M_SRC]);
	272	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
	273	return &(ctx->q_data[V4L2_M2M_DST]);
	274	default:
	275	return NULL;
	276	}
	277	}
	278
	279	const char *coda_product_name(int product);
	280
	281	int coda_check_firmware(struct coda_dev *dev);
	282
2b768468	283	static inline unsigned int coda_get_bitstream_payload(struct coda_ctx *ctx)
79924ca9 PZ	284	{
	285	return kfifo_len(&ctx->bitstream_fifo);
	286	}
	287
	288	void coda_bit_stream_end_flag(struct coda_ctx *ctx);
	289
2d700715	290	void coda_m2m_buf_done(struct coda_ctx ctx, struct vb2_v4l2_buffer buf,
9f2bfb33 PZ	291	enum vb2_buffer_state state);
9f2bfb33 PZ	292
4f4ee9ee	293	int coda_h264_padding(int size, char *p);
79924ca9	294
d4de047b	295	bool coda_jpeg_check_buffer(struct coda_ctx ctx, struct vb2_buffer vb);
cb1d3a33 PZ	296	int coda_jpeg_write_tables(struct coda_ctx *ctx);
	297	void coda_set_jpeg_compression_quality(struct coda_ctx *ctx, int quality);
	298
79924ca9 PZ	299	extern const struct coda_context_ops coda_bit_encode_ops;
	300	extern const struct coda_context_ops coda_bit_decode_ops;
	301
	302	irqreturn_t coda_irq_handler(int irq, void *data);
9a1a8f99 PZ	303
9a1a8f99 PZ	304	#endif /* __CODA_H__ */