[linux-2.6-block.git] / drivers / media / video / tlg2300 / pd-common.h

#ifndef PD_COMMON_H
#define PD_COMMON_H

#include <linux/fs.h>
#include <linux/wait.h>
#include <linux/list.h>
#include <linux/videodev2.h>
#include <linux/semaphore.h>
#include <linux/usb.h>
#include <linux/poll.h>
#include <media/videobuf-vmalloc.h>
#include <media/v4l2-device.h>

#include "dvb_frontend.h"
#include "dvbdev.h"
#include "dvb_demux.h"
#include "dmxdev.h"

#define SBUF_NUM	8
#define MAX_BUFFER_NUM	6
#define PK_PER_URB	32
#define ISO_PKT_SIZE	3072

#define POSEIDON_STATE_NONE		(0x0000)
#define POSEIDON_STATE_ANALOG		(0x0001)
#define POSEIDON_STATE_FM		(0x0002)
#define POSEIDON_STATE_DVBT		(0x0004)
#define POSEIDON_STATE_VBI		(0x0008)
#define POSEIDON_STATE_DISCONNECT	(0x0080)

#define PM_SUSPEND_DELAY	3

#define V4L_PAL_VBI_LINES	18
#define V4L_NTSC_VBI_LINES	12
#define V4L_PAL_VBI_FRAMESIZE	(V4L_PAL_VBI_LINES * 1440 * 2)
#define V4L_NTSC_VBI_FRAMESIZE	(V4L_NTSC_VBI_LINES * 1440 * 2)

#define TUNER_FREQ_MIN		(45000000)
#define TUNER_FREQ_MAX		(862000000)

struct vbi_data {
	struct video_device	*v_dev;
	struct video_data	*video;
	struct front_face	*front;

	unsigned int		copied;
	unsigned int		vbi_size; /* the whole size of two fields */
	int 			users;
};

/*
 * This is the running context of the video, it is useful for
 * resume()
 */
struct running_context {
	u32		freq;		/* VIDIOC_S_FREQUENCY */
	int		audio_idx;	/* VIDIOC_S_TUNER    */
	v4l2_std_id	tvnormid;	/* VIDIOC_S_STD     */
	int		sig_index;	/* VIDIOC_S_INPUT  */
	struct v4l2_pix_format pix;	/* VIDIOC_S_FMT   */
};

struct video_data {
	/* v4l2 video device */
	struct video_device	*v_dev;

	/* the working context */
	struct running_context	context;

	/* for data copy */
	int		field_count;

	char		*dst;
	int		lines_copied;
	int		prev_left;

	int		lines_per_field;
	int		lines_size;

	/* for communication */
	u8			endpoint_addr;
	struct urb 		*urb_array[SBUF_NUM];
	struct vbi_data		*vbi;
	struct poseidon 	*pd;
	struct front_face	*front;

	int			is_streaming;
	int			users;

	/* for bubble handler */
	struct work_struct	bubble_work;
};

enum pcm_stream_state {
	STREAM_OFF,
	STREAM_ON,
	STREAM_SUSPEND,
};

#define AUDIO_BUFS (3)
#define CAPTURE_STREAM_EN 1
struct poseidon_audio {
	struct urb		*urb_array[AUDIO_BUFS];
	unsigned int 		copied_position;
	struct snd_pcm_substream   *capture_pcm_substream;

	unsigned int 		rcv_position;
	struct	snd_card	*card;
	int 			card_close;

	int 			users;
	int			pm_state;
	enum pcm_stream_state 	capture_stream;
};

struct radio_data {
	__u32		fm_freq;
	int		users;
	unsigned int	is_radio_streaming;
	int		pre_emphasis;
	struct video_device *fm_dev;
};

#define DVB_SBUF_NUM		4
#define DVB_URB_BUF_SIZE	0x2000
struct pd_dvb_adapter {
	struct dvb_adapter	dvb_adap;
	struct dvb_frontend	dvb_fe;
	struct dmxdev		dmxdev;
	struct dvb_demux	demux;

	atomic_t		users;
	atomic_t		active_feed;

	/* data transfer */
	s32			is_streaming;
	struct urb		*urb_array[DVB_SBUF_NUM];
	struct poseidon		*pd_device;
	u8			ep_addr;
	u8			reserved[3];

	/* data for power resume*/
	struct dtv_frontend_properties fe_param;

	/* for channel scanning */
	int		prev_freq;
	int		bandwidth;
	unsigned long	last_jiffies;
};

struct front_face {
	/* use this field to distinguish VIDEO and VBI */
	enum v4l2_buf_type	type;

	/* for host */
	struct videobuf_queue	q;

	/* the bridge for host and device */
	struct videobuf_buffer	*curr_frame;

	/* for device */
	spinlock_t		queue_lock;
	struct list_head	active;
	struct poseidon		*pd;
};

struct poseidon {
	struct list_head	device_list;

	struct mutex		lock;
	struct kref		kref;

	/* for V4L2 */
	struct v4l2_device	v4l2_dev;

	/* hardware info */
	struct usb_device	*udev;
	struct usb_interface	*interface;
	int 			cur_transfer_mode;

	struct video_data	video_data;	/* video */
	struct vbi_data		vbi_data;	/* vbi	 */
	struct poseidon_audio	audio;		/* audio (alsa) */
	struct radio_data	radio_data;	/* FM	 */
	struct pd_dvb_adapter	dvb_data;	/* DVB	 */

	u32			state;
	struct file		*file_for_stream; /* the active stream*/

#ifdef CONFIG_PM
	int (*pm_suspend)(struct poseidon *);
	int (*pm_resume)(struct poseidon *);
	pm_message_t		msg;

	struct work_struct	pm_work;
	u8			portnum;
#endif
};

struct poseidon_format {
	char 	*name;
	int	fourcc;		 /* video4linux 2	  */
	int	depth;		 /* bit/pixel		  */
	int	flags;
};

struct poseidon_tvnorm {
	v4l2_std_id	v4l2_id;
	char		name[12];
	u32		tlg_tvnorm;
};

/* video */
int pd_video_init(struct poseidon *);
void pd_video_exit(struct poseidon *);
int stop_all_video_stream(struct poseidon *);

/* alsa audio */
int poseidon_audio_init(struct poseidon *);
int poseidon_audio_free(struct poseidon *);
#ifdef CONFIG_PM
int pm_alsa_suspend(struct poseidon *);
int pm_alsa_resume(struct poseidon *);
#endif

/* dvb */
int pd_dvb_usb_device_init(struct poseidon *);
void pd_dvb_usb_device_exit(struct poseidon *);
void pd_dvb_usb_device_cleanup(struct poseidon *);
int pd_dvb_get_adapter_num(struct pd_dvb_adapter *);
void dvb_stop_streaming(struct pd_dvb_adapter *);

/* FM */
int poseidon_fm_init(struct poseidon *);
int poseidon_fm_exit(struct poseidon *);
struct video_device *vdev_init(struct poseidon *, struct video_device *);

/* vendor command ops */
int send_set_req(struct poseidon*, u8, s32, s32*);
int send_get_req(struct poseidon*, u8, s32, void*, s32*, s32);
s32 set_tuner_mode(struct poseidon*, unsigned char);

/* bulk urb alloc/free */
int alloc_bulk_urbs_generic(struct urb **urb_array, int num,
			struct usb_device *udev, u8 ep_addr,
			int buf_size, gfp_t gfp_flags,
			usb_complete_t complete_fn, void *context);
void free_all_urb_generic(struct urb **urb_array, int num);

/* misc */
void poseidon_delete(struct kref *kref);
void destroy_video_device(struct video_device **v_dev);
extern int debug_mode;
void set_debug_mode(struct video_device *vfd, int debug_mode);

#ifdef CONFIG_PM
#define in_hibernation(pd) (pd->msg.event == PM_EVENT_FREEZE)
#else
#define in_hibernation(pd) (0)
#endif
#define get_pm_count(p) (atomic_read(&(p)->interface->pm_usage_cnt))

#define log(a, ...) printk(KERN_DEBUG "\t[ %s : %.3d ] "a"\n", \
				__func__, __LINE__,  ## __VA_ARGS__)

/* for power management */
#define logpm(pd) do {\
			if (debug_mode & 0x10)\
				log();\
		} while (0)

#define logs(f) do { \
			if ((debug_mode & 0x4) && \
				(f)->type == V4L2_BUF_TYPE_VBI_CAPTURE) \
					log("type : VBI");\
								\
			if ((debug_mode & 0x8) && \
				(f)->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) \
					log("type : VIDEO");\
		} while (0)
#endif
Commit	Line	Data
5b3f03f0 HS	1	#ifndef PD_COMMON_H
	2	#define PD_COMMON_H
	3
5b3f03f0 HS	4	#include <linux/fs.h>
	5	#include <linux/wait.h>
	6	#include <linux/list.h>
	7	#include <linux/videodev2.h>
	8	#include <linux/semaphore.h>
	9	#include <linux/usb.h>
	10	#include <linux/poll.h>
	11	#include <media/videobuf-vmalloc.h>
	12	#include <media/v4l2-device.h>
	13
	14	#include "dvb_frontend.h"
	15	#include "dvbdev.h"
	16	#include "dvb_demux.h"
	17	#include "dmxdev.h"
	18
	19	#define SBUF_NUM 8
	20	#define MAX_BUFFER_NUM 6
	21	#define PK_PER_URB 32
	22	#define ISO_PKT_SIZE 3072
	23
	24	#define POSEIDON_STATE_NONE (0x0000)
	25	#define POSEIDON_STATE_ANALOG (0x0001)
	26	#define POSEIDON_STATE_FM (0x0002)
	27	#define POSEIDON_STATE_DVBT (0x0004)
	28	#define POSEIDON_STATE_VBI (0x0008)
	29	#define POSEIDON_STATE_DISCONNECT (0x0080)
	30
	31	#define PM_SUSPEND_DELAY 3
	32
	33	#define V4L_PAL_VBI_LINES 18
	34	#define V4L_NTSC_VBI_LINES 12
	35	#define V4L_PAL_VBI_FRAMESIZE (V4L_PAL_VBI_LINES * 1440 * 2)
	36	#define V4L_NTSC_VBI_FRAMESIZE (V4L_NTSC_VBI_LINES * 1440 * 2)
	37
	38	#define TUNER_FREQ_MIN (45000000)
	39	#define TUNER_FREQ_MAX (862000000)
	40
	41	struct vbi_data {
	42	struct video_device *v_dev;
	43	struct video_data *video;
	44	struct front_face *front;
	45
	46	unsigned int copied;
	47	unsigned int vbi_size; /* the whole size of two fields */
	48	int users;
	49	};
	50
	51	/*
	52	* This is the running context of the video, it is useful for
	53	* resume()
	54	*/
	55	struct running_context {
	56	u32 freq; /* VIDIOC_S_FREQUENCY */
	57	int audio_idx; /* VIDIOC_S_TUNER */
	58	v4l2_std_id tvnormid; /* VIDIOC_S_STD */
	59	int sig_index; /* VIDIOC_S_INPUT */
	60	struct v4l2_pix_format pix; /* VIDIOC_S_FMT */
	61	};
	62
	63	struct video_data {
	64	/* v4l2 video device */
	65	struct video_device *v_dev;
	66
	67	/* the working context */
68	struct running_context context;
69
70	/* for data copy */
71	int field_count;
72
73	char *dst;
74	int lines_copied;
75	int prev_left;
76
77	int lines_per_field;
78	int lines_size;
79
80	/* for communication */
81	u8 endpoint_addr;
82	struct urb *urb_array[SBUF_NUM];
83	struct vbi_data *vbi;
84	struct poseidon *pd;
85	struct front_face *front;
86
87	int is_streaming;
88	int users;
89
90	/* for bubble handler */
91	struct work_struct bubble_work;
92	};
93
94	enum pcm_stream_state {
95	STREAM_OFF,
96	STREAM_ON,
97	STREAM_SUSPEND,
98	};
99
100	#define AUDIO_BUFS (3)
101	#define CAPTURE_STREAM_EN 1
102	struct poseidon_audio {
103	struct urb *urb_array[AUDIO_BUFS];
104	unsigned int copied_position;
105	struct snd_pcm_substream *capture_pcm_substream;
106
107	unsigned int rcv_position;
108	struct snd_card *card;
109	int card_close;
110
111	int users;
112	int pm_state;
113	enum pcm_stream_state capture_stream;
114	};
115
116	struct radio_data {
117	__u32 fm_freq;
118	int users;
119	unsigned int is_radio_streaming;
007ad830	120	int pre_emphasis;
5b3f03f0 HS	121	struct video_device *fm_dev;
	122	};
	123
	124	#define DVB_SBUF_NUM 4
	125	#define DVB_URB_BUF_SIZE 0x2000
	126	struct pd_dvb_adapter {
	127	struct dvb_adapter dvb_adap;
	128	struct dvb_frontend dvb_fe;
	129	struct dmxdev dmxdev;
	130	struct dvb_demux demux;
	131
	132	atomic_t users;
	133	atomic_t active_feed;
	134
	135	/* data transfer */
	136	s32 is_streaming;
	137	struct urb *urb_array[DVB_SBUF_NUM];
	138	struct poseidon *pd_device;
	139	u8 ep_addr;
	140	u8 reserved[3];
	141
	142	/* data for power resume*/
2827e1ff	143	struct dtv_frontend_properties fe_param;
5b3f03f0 HS	144
	145	/* for channel scanning */
	146	int prev_freq;
	147	int bandwidth;
	148	unsigned long last_jiffies;
	149	};
	150
	151	struct front_face {
	152	/* use this field to distinguish VIDEO and VBI */
	153	enum v4l2_buf_type type;
	154
	155	/* for host */
	156	struct videobuf_queue q;
	157
	158	/* the bridge for host and device */
	159	struct videobuf_buffer *curr_frame;
	160
	161	/* for device */
	162	spinlock_t queue_lock;
	163	struct list_head active;
	164	struct poseidon *pd;
	165	};
	166
	167	struct poseidon {
	168	struct list_head device_list;
	169
	170	struct mutex lock;
	171	struct kref kref;
	172
	173	/* for V4L2 */
	174	struct v4l2_device v4l2_dev;
	175
	176	/* hardware info */
	177	struct usb_device *udev;
	178	struct usb_interface *interface;
	179	int cur_transfer_mode;
	180
	181	struct video_data video_data; /* video */
	182	struct vbi_data vbi_data; /* vbi */
	183	struct poseidon_audio audio; /* audio (alsa) */
	184	struct radio_data radio_data; /* FM */
	185	struct pd_dvb_adapter dvb_data; /* DVB */
	186
	187	u32 state;
5b3f03f0 HS	188	struct file file_for_stream; / the active stream*/
	189
	190	#ifdef CONFIG_PM
	191	int (pm_suspend)(struct poseidon );
	192	int (pm_resume)(struct poseidon );
	193	pm_message_t msg;
	194
	195	struct work_struct pm_work;
	196	u8 portnum;
	197	#endif
	198	};
	199
	200	struct poseidon_format {
	201	char *name;
	202	int fourcc; /* video4linux 2 */
	203	int depth; /* bit/pixel */
	204	int flags;
	205	};
	206
	207	struct poseidon_tvnorm {
	208	v4l2_std_id v4l2_id;
	209	char name[12];
	210	u32 tlg_tvnorm;
	211	};
	212
	213	/* video */
	214	int pd_video_init(struct poseidon *);
	215	void pd_video_exit(struct poseidon *);
	216	int stop_all_video_stream(struct poseidon *);
	217
	218	/* alsa audio */
	219	int poseidon_audio_init(struct poseidon *);
	220	int poseidon_audio_free(struct poseidon *);
	221	#ifdef CONFIG_PM
	222	int pm_alsa_suspend(struct poseidon *);
	223	int pm_alsa_resume(struct poseidon *);
	224	#endif
	225
	226	/* dvb */
	227	int pd_dvb_usb_device_init(struct poseidon *);
	228	void pd_dvb_usb_device_exit(struct poseidon *);
	229	void pd_dvb_usb_device_cleanup(struct poseidon *);
	230	int pd_dvb_get_adapter_num(struct pd_dvb_adapter *);
	231	void dvb_stop_streaming(struct pd_dvb_adapter *);
	232
	233	/* FM */
	234	int poseidon_fm_init(struct poseidon *);
	235	int poseidon_fm_exit(struct poseidon *);
	236	struct video_device vdev_init(struct poseidon , struct video_device *);
	237
	238	/* vendor command ops */
	239	int send_set_req(struct poseidon, u8, s32, s32);
	240	int send_get_req(struct poseidon, u8, s32, void, s32*, s32);
	241	s32 set_tuner_mode(struct poseidon*, unsigned char);
5b3f03f0 HS	242
	243	/* bulk urb alloc/free */
	244	int alloc_bulk_urbs_generic(struct urb **urb_array, int num,
	245	struct usb_device *udev, u8 ep_addr,
	246	int buf_size, gfp_t gfp_flags,
	247	usb_complete_t complete_fn, void *context);
	248	void free_all_urb_generic(struct urb **urb_array, int num);
	249
	250	/* misc */
	251	void poseidon_delete(struct kref *kref);
	252	void destroy_video_device(struct video_device **v_dev);
5b3f03f0 HS	253	extern int debug_mode;
	254	void set_debug_mode(struct video_device *vfd, int debug_mode);
	255
08cf8a57	256	#ifdef CONFIG_PM
5b3f03f0	257	#define in_hibernation(pd) (pd->msg.event == PM_EVENT_FREEZE)
08cf8a57 RD	258	#else
	259	#define in_hibernation(pd) (0)
	260	#endif
5b3f03f0 HS	261	#define get_pm_count(p) (atomic_read(&(p)->interface->pm_usage_cnt))
	262
	263	#define log(a, ...) printk(KERN_DEBUG "\t[ %s : %.3d ] "a"\n", \
	264	__func__, __LINE__, ## __VA_ARGS__)
	265
	266	/* for power management */
	267	#define logpm(pd) do {\
	268	if (debug_mode & 0x10)\
	269	log();\
	270	} while (0)
	271
	272	#define logs(f) do { \
	273	if ((debug_mode & 0x4) && \
	274	(f)->type == V4L2_BUF_TYPE_VBI_CAPTURE) \
	275	log("type : VBI");\
	276	\
	277	if ((debug_mode & 0x8) && \
	278	(f)->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) \
	279	log("type : VIDEO");\
	280	} while (0)
	281	#endif