[linux-2.6-block.git] / drivers / staging / media / omap4iss / iss_video.h

/*
 * TI OMAP4 ISS V4L2 Driver - Generic video node
 *
 * Copyright (C) 2012 Texas Instruments, Inc.
 *
 * Author: Sergio Aguirre <sergio.a.aguirre@gmail.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.
 */

#ifndef OMAP4_ISS_VIDEO_H
#define OMAP4_ISS_VIDEO_H

#include <linux/v4l2-mediabus.h>
#include <media/media-entity.h>
#include <media/v4l2-dev.h>
#include <media/v4l2-fh.h>
#include <media/videobuf2-v4l2.h>
#include <media/videobuf2-dma-contig.h>

#define ISS_VIDEO_DRIVER_NAME		"issvideo"
#define ISS_VIDEO_DRIVER_VERSION	"0.0.2"

struct iss_device;
struct iss_video;
struct v4l2_mbus_framefmt;
struct v4l2_pix_format;

/*
 * struct iss_format_info - ISS media bus format information
 * @code: V4L2 media bus format code
 * @truncated: V4L2 media bus format code for the same format truncated to 10
 *	bits. Identical to @code if the format is 10 bits wide or less.
 * @uncompressed: V4L2 media bus format code for the corresponding uncompressed
 *	format. Identical to @code if the format is not DPCM compressed.
 * @flavor: V4L2 media bus format code for the same pixel layout but
 *	shifted to be 8 bits per pixel. =0 if format is not shiftable.
 * @pixelformat: V4L2 pixel format FCC identifier
 * @bpp: Bits per pixel
 * @description: Human-readable format description
 */
struct iss_format_info {
	u32 code;
	u32 truncated;
	u32 uncompressed;
	u32 flavor;
	u32 pixelformat;
	unsigned int bpp;
	const char *description;
};

enum iss_pipeline_stream_state {
	ISS_PIPELINE_STREAM_STOPPED = 0,
	ISS_PIPELINE_STREAM_CONTINUOUS = 1,
	ISS_PIPELINE_STREAM_SINGLESHOT = 2,
};

enum iss_pipeline_state {
	/* The stream has been started on the input video node. */
	ISS_PIPELINE_STREAM_INPUT = 1,
	/* The stream has been started on the output video node. */
	ISS_PIPELINE_STREAM_OUTPUT = (1 << 1),
	/* At least one buffer is queued on the input video node. */
	ISS_PIPELINE_QUEUE_INPUT = (1 << 2),
	/* At least one buffer is queued on the output video node. */
	ISS_PIPELINE_QUEUE_OUTPUT = (1 << 3),
	/* The input entity is idle, ready to be started. */
	ISS_PIPELINE_IDLE_INPUT = (1 << 4),
	/* The output entity is idle, ready to be started. */
	ISS_PIPELINE_IDLE_OUTPUT = (1 << 5),
	/* The pipeline is currently streaming. */
	ISS_PIPELINE_STREAM = (1 << 6),
};

/*
 * struct iss_pipeline - An OMAP4 ISS hardware pipeline
 * @ent_enum: Entities in the pipeline
 * @error: A hardware error occurred during capture
 */
struct iss_pipeline {
	struct media_pipeline pipe;
	spinlock_t lock;		/* Pipeline state and queue flags */
	unsigned int state;
	enum iss_pipeline_stream_state stream_state;
	struct iss_video *input;
	struct iss_video *output;
	struct media_entity_enum ent_enum;
	atomic_t frame_number;
	bool do_propagation; /* of frame number */
	bool error;
	struct v4l2_fract max_timeperframe;
	struct v4l2_subdev *external;
	unsigned int external_rate;
	int external_bpp;
};

#define to_iss_pipeline(__e) \
	container_of((__e)->pipe, struct iss_pipeline, pipe)

static inline int iss_pipeline_ready(struct iss_pipeline *pipe)
{
	return pipe->state == (ISS_PIPELINE_STREAM_INPUT |
			       ISS_PIPELINE_STREAM_OUTPUT |
			       ISS_PIPELINE_QUEUE_INPUT |
			       ISS_PIPELINE_QUEUE_OUTPUT |
			       ISS_PIPELINE_IDLE_INPUT |
			       ISS_PIPELINE_IDLE_OUTPUT);
}

/*
 * struct iss_buffer - ISS buffer
 * @buffer: ISS video buffer
 * @iss_addr: Physical address of the buffer.
 */
struct iss_buffer {
	/* common v4l buffer stuff -- must be first */
	struct vb2_v4l2_buffer	vb;
	struct list_head	list;
	dma_addr_t iss_addr;
};

#define to_iss_buffer(buf)	container_of(buf, struct iss_buffer, vb)

enum iss_video_dmaqueue_flags {
	/* Set if DMA queue becomes empty when ISS_PIPELINE_STREAM_CONTINUOUS */
	ISS_VIDEO_DMAQUEUE_UNDERRUN = (1 << 0),
	/* Set when queuing buffer to an empty DMA queue */
	ISS_VIDEO_DMAQUEUE_QUEUED = (1 << 1),
};

#define iss_video_dmaqueue_flags_clr(video)	\
			({ (video)->dmaqueue_flags = 0; })

/*
 * struct iss_video_operations - ISS video operations
 * @queue:	Resume streaming when a buffer is queued. Called on VIDIOC_QBUF
 *		if there was no buffer previously queued.
 */
struct iss_video_operations {
	int (*queue)(struct iss_video *video, struct iss_buffer *buffer);
};

struct iss_video {
	struct video_device video;
	enum v4l2_buf_type type;
	struct media_pad pad;

	struct mutex mutex;		/* format and crop settings */
	atomic_t active;

	struct iss_device *iss;

	unsigned int capture_mem;
	unsigned int bpl_alignment;	/* alignment value */
	unsigned int bpl_zero_padding;	/* whether the alignment is optional */
	unsigned int bpl_max;		/* maximum bytes per line value */
	unsigned int bpl_value;		/* bytes per line value */
	unsigned int bpl_padding;	/* padding at end of line */

	/* Pipeline state */
	struct iss_pipeline pipe;
	struct mutex stream_lock;	/* pipeline and stream states */
	bool error;

	/* Video buffers queue */
	struct vb2_queue *queue;
	spinlock_t qlock;		/* protects dmaqueue and error */
	struct list_head dmaqueue;
	enum iss_video_dmaqueue_flags dmaqueue_flags;
	struct vb2_alloc_ctx *alloc_ctx;

	const struct iss_video_operations *ops;
};

#define to_iss_video(vdev)	container_of(vdev, struct iss_video, video)

struct iss_video_fh {
	struct v4l2_fh vfh;
	struct iss_video *video;
	struct vb2_queue queue;
	struct v4l2_format format;
	struct v4l2_fract timeperframe;
};

#define to_iss_video_fh(fh)	container_of(fh, struct iss_video_fh, vfh)
#define iss_video_queue_to_iss_video_fh(q) \
				container_of(q, struct iss_video_fh, queue)

int omap4iss_video_init(struct iss_video *video, const char *name);
void omap4iss_video_cleanup(struct iss_video *video);
int omap4iss_video_register(struct iss_video *video,
			    struct v4l2_device *vdev);
void omap4iss_video_unregister(struct iss_video *video);
struct iss_buffer *omap4iss_video_buffer_next(struct iss_video *video);
void omap4iss_video_cancel_stream(struct iss_video *video);
struct media_pad *omap4iss_video_remote_pad(struct iss_video *video);

const struct iss_format_info *
omap4iss_video_format_info(u32 code);

#endif /* OMAP4_ISS_VIDEO_H */
Commit	Line	Data
fc96d58c SA	1	/*
	2	* TI OMAP4 ISS V4L2 Driver - Generic video node
	3	*
	4	* Copyright (C) 2012 Texas Instruments, Inc.
	5	*
	6	* Author: Sergio Aguirre <sergio.a.aguirre@gmail.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	#ifndef OMAP4_ISS_VIDEO_H
	15	#define OMAP4_ISS_VIDEO_H
	16
	17	#include <linux/v4l2-mediabus.h>
	18	#include <media/media-entity.h>
	19	#include <media/v4l2-dev.h>
	20	#include <media/v4l2-fh.h>
c139990e	21	#include <media/videobuf2-v4l2.h>
fc96d58c SA	22	#include <media/videobuf2-dma-contig.h>
	23
	24	#define ISS_VIDEO_DRIVER_NAME "issvideo"
	25	#define ISS_VIDEO_DRIVER_VERSION "0.0.2"
	26
	27	struct iss_device;
	28	struct iss_video;
	29	struct v4l2_mbus_framefmt;
	30	struct v4l2_pix_format;
	31
	32	/*
	33	* struct iss_format_info - ISS media bus format information
	34	* @code: V4L2 media bus format code
	35	* @truncated: V4L2 media bus format code for the same format truncated to 10
	36	* bits. Identical to @code if the format is 10 bits wide or less.
	37	* @uncompressed: V4L2 media bus format code for the corresponding uncompressed
	38	* format. Identical to @code if the format is not DPCM compressed.
	39	* @flavor: V4L2 media bus format code for the same pixel layout but
	40	* shifted to be 8 bits per pixel. =0 if format is not shiftable.
	41	* @pixelformat: V4L2 pixel format FCC identifier
	42	* @bpp: Bits per pixel
a1d4eab0	43	* @description: Human-readable format description
fc96d58c SA	44	*/
fc96d58c SA	45	struct iss_format_info {
3336f07a BB	46	u32 code;
	47	u32 truncated;
	48	u32 uncompressed;
	49	u32 flavor;
fc96d58c SA	50	u32 pixelformat;
fc96d58c SA	51	unsigned int bpp;
a1d4eab0	52	const char *description;
fc96d58c SA	53	};
	54
	55	enum iss_pipeline_stream_state {
	56	ISS_PIPELINE_STREAM_STOPPED = 0,
	57	ISS_PIPELINE_STREAM_CONTINUOUS = 1,
	58	ISS_PIPELINE_STREAM_SINGLESHOT = 2,
	59	};
	60
	61	enum iss_pipeline_state {
	62	/* The stream has been started on the input video node. */
	63	ISS_PIPELINE_STREAM_INPUT = 1,
	64	/* The stream has been started on the output video node. */
	65	ISS_PIPELINE_STREAM_OUTPUT = (1 << 1),
	66	/* At least one buffer is queued on the input video node. */
	67	ISS_PIPELINE_QUEUE_INPUT = (1 << 2),
	68	/* At least one buffer is queued on the output video node. */
	69	ISS_PIPELINE_QUEUE_OUTPUT = (1 << 3),
	70	/* The input entity is idle, ready to be started. */
	71	ISS_PIPELINE_IDLE_INPUT = (1 << 4),
	72	/* The output entity is idle, ready to be started. */
	73	ISS_PIPELINE_IDLE_OUTPUT = (1 << 5),
	74	/* The pipeline is currently streaming. */
	75	ISS_PIPELINE_STREAM = (1 << 6),
	76	};
	77
	78	/*
	79	* struct iss_pipeline - An OMAP4 ISS hardware pipeline
6246b2a7	80	* @ent_enum: Entities in the pipeline
fc96d58c SA	81	* @error: A hardware error occurred during capture
	82	*/
	83	struct iss_pipeline {
	84	struct media_pipeline pipe;
	85	spinlock_t lock; /* Pipeline state and queue flags */
	86	unsigned int state;
	87	enum iss_pipeline_stream_state stream_state;
	88	struct iss_video *input;
	89	struct iss_video *output;
6246b2a7	90	struct media_entity_enum ent_enum;
fc96d58c SA	91	atomic_t frame_number;
	92	bool do_propagation; /* of frame number */
	93	bool error;
	94	struct v4l2_fract max_timeperframe;
	95	struct v4l2_subdev *external;
	96	unsigned int external_rate;
	97	int external_bpp;
	98	};
	99
	100	#define to_iss_pipeline(__e) \
	101	container_of((__e)->pipe, struct iss_pipeline, pipe)
	102
	103	static inline int iss_pipeline_ready(struct iss_pipeline *pipe)
	104	{
	105	return pipe->state == (ISS_PIPELINE_STREAM_INPUT \|
	106	ISS_PIPELINE_STREAM_OUTPUT \|
	107	ISS_PIPELINE_QUEUE_INPUT \|
	108	ISS_PIPELINE_QUEUE_OUTPUT \|
	109	ISS_PIPELINE_IDLE_INPUT \|
	110	ISS_PIPELINE_IDLE_OUTPUT);
	111	}
	112
	113	/*
	114	* struct iss_buffer - ISS buffer
	115	* @buffer: ISS video buffer
	116	* @iss_addr: Physical address of the buffer.
	117	*/
	118	struct iss_buffer {
	119	/* common v4l buffer stuff -- must be first */
2d700715	120	struct vb2_v4l2_buffer vb;
fc96d58c SA	121	struct list_head list;
	122	dma_addr_t iss_addr;
	123	};
	124
2d700715	125	#define to_iss_buffer(buf) container_of(buf, struct iss_buffer, vb)
fc96d58c SA	126
	127	enum iss_video_dmaqueue_flags {
	128	/* Set if DMA queue becomes empty when ISS_PIPELINE_STREAM_CONTINUOUS */
	129	ISS_VIDEO_DMAQUEUE_UNDERRUN = (1 << 0),
	130	/* Set when queuing buffer to an empty DMA queue */
	131	ISS_VIDEO_DMAQUEUE_QUEUED = (1 << 1),
	132	};
	133
	134	#define iss_video_dmaqueue_flags_clr(video) \
	135	({ (video)->dmaqueue_flags = 0; })
	136
	137	/*
	138	* struct iss_video_operations - ISS video operations
	139	* @queue: Resume streaming when a buffer is queued. Called on VIDIOC_QBUF
	140	* if there was no buffer previously queued.
	141	*/
	142	struct iss_video_operations {
47a963f1	143	int (queue)(struct iss_video video, struct iss_buffer *buffer);
fc96d58c SA	144	};
	145
	146	struct iss_video {
	147	struct video_device video;
	148	enum v4l2_buf_type type;
	149	struct media_pad pad;
	150
	151	struct mutex mutex; /* format and crop settings */
	152	atomic_t active;
	153
	154	struct iss_device *iss;
	155
	156	unsigned int capture_mem;
	157	unsigned int bpl_alignment; /* alignment value */
	158	unsigned int bpl_zero_padding; /* whether the alignment is optional */
	159	unsigned int bpl_max; /* maximum bytes per line value */
	160	unsigned int bpl_value; /* bytes per line value */
	161	unsigned int bpl_padding; /* padding at end of line */
	162
fc96d58c SA	163	/* Pipeline state */
	164	struct iss_pipeline pipe;
	165	struct mutex stream_lock; /* pipeline and stream states */
112da085	166	bool error;
fc96d58c SA	167
	168	/* Video buffers queue */
	169	struct vb2_queue *queue;
112da085	170	spinlock_t qlock; /* protects dmaqueue and error */
fc96d58c SA	171	struct list_head dmaqueue;
	172	enum iss_video_dmaqueue_flags dmaqueue_flags;
	173	struct vb2_alloc_ctx *alloc_ctx;
	174
	175	const struct iss_video_operations *ops;
	176	};
	177
	178	#define to_iss_video(vdev) container_of(vdev, struct iss_video, video)
	179
	180	struct iss_video_fh {
	181	struct v4l2_fh vfh;
	182	struct iss_video *video;
	183	struct vb2_queue queue;
	184	struct v4l2_format format;
	185	struct v4l2_fract timeperframe;
	186	};
	187
	188	#define to_iss_video_fh(fh) container_of(fh, struct iss_video_fh, vfh)
	189	#define iss_video_queue_to_iss_video_fh(q) \
	190	container_of(q, struct iss_video_fh, queue)
	191
	192	int omap4iss_video_init(struct iss_video video, const char name);
	193	void omap4iss_video_cleanup(struct iss_video *video);
	194	int omap4iss_video_register(struct iss_video *video,
	195	struct v4l2_device *vdev);
	196	void omap4iss_video_unregister(struct iss_video *video);
	197	struct iss_buffer omap4iss_video_buffer_next(struct iss_video video);
112da085	198	void omap4iss_video_cancel_stream(struct iss_video *video);
fc96d58c SA	199	struct media_pad omap4iss_video_remote_pad(struct iss_video video);
	200
	201	const struct iss_format_info *
3336f07a	202	omap4iss_video_format_info(u32 code);
fc96d58c SA	203
fc96d58c SA	204	#endif /* OMAP4_ISS_VIDEO_H */