[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / video / pvrusb2 / pvrusb2-cx2584x-v4l.c

/*
 *
 *
 *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
 *  Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
 *
 *  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
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/*

   This source file is specifically designed to interface with the
   cx2584x, in kernels 2.6.16 or newer.

*/

#include "pvrusb2-cx2584x-v4l.h"
#include "pvrusb2-video-v4l.h"
#include "pvrusb2-i2c-cmd-v4l2.h"


#include "pvrusb2-hdw-internal.h"
#include "pvrusb2-debug.h"
#include <media/cx25840.h>
#include <linux/videodev2.h>
#include <media/v4l2-common.h>
#include <linux/errno.h>
#include <linux/slab.h>

struct pvr2_v4l_cx2584x {
	struct pvr2_i2c_handler handler;
	struct pvr2_decoder_ctrl ctrl;
	struct pvr2_i2c_client *client;
	struct pvr2_hdw *hdw;
	unsigned long stale_mask;
};


struct routing_scheme_item {
	int vid;
	int aud;
};

struct routing_scheme {
	const struct routing_scheme_item *def;
	unsigned int cnt;
};

static const struct routing_scheme_item routing_scheme0[] = {
	[PVR2_CVAL_INPUT_TV] = {
		.vid = CX25840_COMPOSITE7,
		.aud = CX25840_AUDIO8,
	},
	[PVR2_CVAL_INPUT_RADIO] = { /* Treat the same as composite */
		.vid = CX25840_COMPOSITE3,
		.aud = CX25840_AUDIO_SERIAL,
	},
	[PVR2_CVAL_INPUT_COMPOSITE] = {
		.vid = CX25840_COMPOSITE3,
		.aud = CX25840_AUDIO_SERIAL,
	},
	[PVR2_CVAL_INPUT_SVIDEO] = {
		.vid = CX25840_SVIDEO1,
		.aud = CX25840_AUDIO_SERIAL,
	},
};

/* Specific to gotview device */
static const struct routing_scheme_item routing_schemegv[] = {
	[PVR2_CVAL_INPUT_TV] = {
		.vid = CX25840_COMPOSITE2,
		.aud = CX25840_AUDIO5,
	},
	[PVR2_CVAL_INPUT_RADIO] = {
		/* line-in is used for radio and composite.  A GPIO is
		   used to switch between the two choices. */
		.vid = CX25840_COMPOSITE1,
		.aud = CX25840_AUDIO_SERIAL,
	},
	[PVR2_CVAL_INPUT_COMPOSITE] = {
		.vid = CX25840_COMPOSITE1,
		.aud = CX25840_AUDIO_SERIAL,
	},
	[PVR2_CVAL_INPUT_SVIDEO] = {
		.vid = (CX25840_SVIDEO_LUMA3|CX25840_SVIDEO_CHROMA4),
		.aud = CX25840_AUDIO_SERIAL,
	},
};

static const struct routing_scheme routing_schemes[] = {
	[PVR2_ROUTING_SCHEME_HAUPPAUGE] = {
		.def = routing_scheme0,
		.cnt = ARRAY_SIZE(routing_scheme0),
	},
	[PVR2_ROUTING_SCHEME_GOTVIEW] = {
		.def = routing_schemegv,
		.cnt = ARRAY_SIZE(routing_schemegv),
	},
};

static void set_input(struct pvr2_v4l_cx2584x *ctxt)
{
	struct pvr2_hdw *hdw = ctxt->hdw;
	struct v4l2_routing route;
	enum cx25840_video_input vid_input;
	enum cx25840_audio_input aud_input;
	const struct routing_scheme *sp;
	unsigned int sid = hdw->hdw_desc->signal_routing_scheme;

	memset(&route,0,sizeof(route));

	if ((sid < ARRAY_SIZE(routing_schemes)) &&
	    ((sp = routing_schemes + sid) != NULL) &&
	    (hdw->input_val >= 0) &&
	    (hdw->input_val < sp->cnt)) {
		vid_input = sp->def[hdw->input_val].vid;
		aud_input = sp->def[hdw->input_val].aud;
	} else {
		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
			   "*** WARNING *** i2c cx2584x set_input:"
			   " Invalid routing scheme (%u) and/or input (%d)",
			   sid,hdw->input_val);
		return;
	}

	pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx2584x set_input vid=0x%x aud=0x%x",
		   vid_input,aud_input);
	route.input = (u32)vid_input;
	pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_S_VIDEO_ROUTING,&route);
	route.input = (u32)aud_input;
	pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_S_AUDIO_ROUTING,&route);
}


static int check_input(struct pvr2_v4l_cx2584x *ctxt)
{
	struct pvr2_hdw *hdw = ctxt->hdw;
	return hdw->input_dirty != 0;
}


static void set_audio(struct pvr2_v4l_cx2584x *ctxt)
{
	u32 val;
	struct pvr2_hdw *hdw = ctxt->hdw;

	pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx2584x set_audio %d",
		   hdw->srate_val);
	switch (hdw->srate_val) {
	default:
	case V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000:
		val = 48000;
		break;
	case V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100:
		val = 44100;
		break;
	case V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000:
		val = 32000;
		break;
	}
	pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_AUDIO_CLOCK_FREQ,&val);
}


static int check_audio(struct pvr2_v4l_cx2584x *ctxt)
{
	struct pvr2_hdw *hdw = ctxt->hdw;
	return hdw->srate_dirty != 0;
}


struct pvr2_v4l_cx2584x_ops {
	void (*update)(struct pvr2_v4l_cx2584x *);
	int (*check)(struct pvr2_v4l_cx2584x *);
};


static const struct pvr2_v4l_cx2584x_ops decoder_ops[] = {
	{ .update = set_input, .check = check_input},
	{ .update = set_audio, .check = check_audio},
};


static void decoder_detach(struct pvr2_v4l_cx2584x *ctxt)
{
	ctxt->client->handler = NULL;
	pvr2_hdw_set_decoder(ctxt->hdw,NULL);
	kfree(ctxt);
}


static int decoder_check(struct pvr2_v4l_cx2584x *ctxt)
{
	unsigned long msk;
	unsigned int idx;

	for (idx = 0; idx < ARRAY_SIZE(decoder_ops); idx++) {
		msk = 1 << idx;
		if (ctxt->stale_mask & msk) continue;
		if (decoder_ops[idx].check(ctxt)) {
			ctxt->stale_mask |= msk;
		}
	}
	return ctxt->stale_mask != 0;
}


static void decoder_update(struct pvr2_v4l_cx2584x *ctxt)
{
	unsigned long msk;
	unsigned int idx;

	for (idx = 0; idx < ARRAY_SIZE(decoder_ops); idx++) {
		msk = 1 << idx;
		if (!(ctxt->stale_mask & msk)) continue;
		ctxt->stale_mask &= ~msk;
		decoder_ops[idx].update(ctxt);
	}
}


static void decoder_enable(struct pvr2_v4l_cx2584x *ctxt,int fl)
{
	pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx25840 decoder_enable(%d)",fl);
	pvr2_v4l2_cmd_stream(ctxt->client,fl);
}


static int decoder_detect(struct pvr2_i2c_client *cp)
{
	int ret;
	/* Attempt to query the decoder - let's see if it will answer */
	struct v4l2_queryctrl qc;

	memset(&qc,0,sizeof(qc));

	qc.id = V4L2_CID_BRIGHTNESS;

	ret = pvr2_i2c_client_cmd(cp,VIDIOC_QUERYCTRL,&qc);
	return ret == 0; /* Return true if it answered */
}


static unsigned int decoder_describe(struct pvr2_v4l_cx2584x *ctxt,
				     char *buf,unsigned int cnt)
{
	return scnprintf(buf,cnt,"handler: pvrusb2-cx2584x-v4l");
}


static void decoder_reset(struct pvr2_v4l_cx2584x *ctxt)
{
	int ret;
	ret = pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_RESET,NULL);
	pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx25840 decoder_reset (ret=%d)",ret);
}


static const struct pvr2_i2c_handler_functions hfuncs = {
	.detach = (void (*)(void *))decoder_detach,
	.check = (int (*)(void *))decoder_check,
	.update = (void (*)(void *))decoder_update,
	.describe = (unsigned int (*)(void *,char *,unsigned int))decoder_describe,
};


int pvr2_i2c_cx2584x_v4l_setup(struct pvr2_hdw *hdw,
			       struct pvr2_i2c_client *cp)
{
	struct pvr2_v4l_cx2584x *ctxt;

	if (hdw->decoder_ctrl) return 0;
	if (cp->handler) return 0;
	if (!decoder_detect(cp)) return 0;

	ctxt = kzalloc(sizeof(*ctxt),GFP_KERNEL);
	if (!ctxt) return 0;

	ctxt->handler.func_data = ctxt;
	ctxt->handler.func_table = &hfuncs;
	ctxt->ctrl.ctxt = ctxt;
	ctxt->ctrl.detach = (void (*)(void *))decoder_detach;
	ctxt->ctrl.enable = (void (*)(void *,int))decoder_enable;
	ctxt->ctrl.force_reset = (void (*)(void*))decoder_reset;
	ctxt->client = cp;
	ctxt->hdw = hdw;
	ctxt->stale_mask = (1 << ARRAY_SIZE(decoder_ops)) - 1;
	pvr2_hdw_set_decoder(hdw,&ctxt->ctrl);
	cp->handler = &ctxt->handler;
	{
		/*
		  Mike Isely <isely@pobox.com> 19-Nov-2006 - This bit
		  of nuttiness for cx25840 causes that module to
		  correctly set up its video scaling.  This is really
		  a problem in the cx25840 module itself, but we work
		  around it here.  The problem has not been seen in
		  ivtv because there VBI is supported and set up.  We
		  don't do VBI here (at least not yet) and thus we
		  never attempted to even set it up.
		 */
		struct v4l2_format fmt;
		memset(&fmt,0,sizeof(fmt));
		fmt.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
		pvr2_i2c_client_cmd(ctxt->client,VIDIOC_S_FMT,&fmt);
	}
	pvr2_trace(PVR2_TRACE_CHIPS,"i2c 0x%x cx2584x V4L2 handler set up",
		   cp->client->addr);
	return !0;
}


/*
  Stuff for Emacs to see, in order to encourage consistent editing style:
  *** Local Variables: ***
  *** mode: c ***
  *** fill-column: 70 ***
  *** tab-width: 8 ***
  *** c-basic-offset: 8 ***
  *** End: ***
  */
Commit	Line	Data
d855497e MI	1	/*
d855497e MI	2	*
d855497e MI	3	*
	4	* Copyright (C) 2005 Mike Isely <isely@pobox.com>
	5	* Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*
	20	*/
	21
	22	/*
	23
	24	This source file is specifically designed to interface with the
	25	cx2584x, in kernels 2.6.16 or newer.
	26
	27	*/
	28
	29	#include "pvrusb2-cx2584x-v4l.h"
	30	#include "pvrusb2-video-v4l.h"
	31	#include "pvrusb2-i2c-cmd-v4l2.h"
	32
	33
	34	#include "pvrusb2-hdw-internal.h"
	35	#include "pvrusb2-debug.h"
	36	#include <media/cx25840.h>
	37	#include <linux/videodev2.h>
	38	#include <media/v4l2-common.h>
	39	#include <linux/errno.h>
	40	#include <linux/slab.h>
	41
	42	struct pvr2_v4l_cx2584x {
	43	struct pvr2_i2c_handler handler;
	44	struct pvr2_decoder_ctrl ctrl;
	45	struct pvr2_i2c_client *client;
	46	struct pvr2_hdw *hdw;
	47	unsigned long stale_mask;
	48	};
	49
	50
f5174af2 MI	51	struct routing_scheme_item {
	52	int vid;
	53	int aud;
	54	};
	55
	56	struct routing_scheme {
	57	const struct routing_scheme_item *def;
	58	unsigned int cnt;
	59	};
	60
	61	static const struct routing_scheme_item routing_scheme0[] = {
	62	[PVR2_CVAL_INPUT_TV] = {
	63	.vid = CX25840_COMPOSITE7,
	64	.aud = CX25840_AUDIO8,
	65	},
	66	[PVR2_CVAL_INPUT_RADIO] = { /* Treat the same as composite */
	67	.vid = CX25840_COMPOSITE3,
	68	.aud = CX25840_AUDIO_SERIAL,
	69	},
	70	[PVR2_CVAL_INPUT_COMPOSITE] = {
	71	.vid = CX25840_COMPOSITE3,
	72	.aud = CX25840_AUDIO_SERIAL,
	73	},
	74	[PVR2_CVAL_INPUT_SVIDEO] = {
	75	.vid = CX25840_SVIDEO1,
	76	.aud = CX25840_AUDIO_SERIAL,
	77	},
	78	};
	79
9e2e3aeb MI	80	/* Specific to gotview device */
	81	static const struct routing_scheme_item routing_schemegv[] = {
	82	[PVR2_CVAL_INPUT_TV] = {
	83	.vid = CX25840_COMPOSITE2,
	84	.aud = CX25840_AUDIO5,
	85	},
1df59f0b MI	86	[PVR2_CVAL_INPUT_RADIO] = {
	87	/* line-in is used for radio and composite. A GPIO is
	88	used to switch between the two choices. */
9e2e3aeb MI	89	.vid = CX25840_COMPOSITE1,
	90	.aud = CX25840_AUDIO_SERIAL,
	91	},
	92	[PVR2_CVAL_INPUT_COMPOSITE] = {
	93	.vid = CX25840_COMPOSITE1,
	94	.aud = CX25840_AUDIO_SERIAL,
	95	},
	96	[PVR2_CVAL_INPUT_SVIDEO] = {
	97	.vid = (CX25840_SVIDEO_LUMA3\|CX25840_SVIDEO_CHROMA4),
	98	.aud = CX25840_AUDIO_SERIAL,
	99	},
	100	};
	101
f5174af2 MI	102	static const struct routing_scheme routing_schemes[] = {
	103	[PVR2_ROUTING_SCHEME_HAUPPAUGE] = {
	104	.def = routing_scheme0,
	105	.cnt = ARRAY_SIZE(routing_scheme0),
	106	},
9e2e3aeb MI	107	[PVR2_ROUTING_SCHEME_GOTVIEW] = {
	108	.def = routing_schemegv,
	109	.cnt = ARRAY_SIZE(routing_schemegv),
	110	},
f5174af2 MI	111	};
f5174af2 MI	112
d855497e MI	113	static void set_input(struct pvr2_v4l_cx2584x *ctxt)
	114	{
	115	struct pvr2_hdw *hdw = ctxt->hdw;
	116	struct v4l2_routing route;
	117	enum cx25840_video_input vid_input;
	118	enum cx25840_audio_input aud_input;
f5174af2 MI	119	const struct routing_scheme *sp;
f5174af2 MI	120	unsigned int sid = hdw->hdw_desc->signal_routing_scheme;
d855497e MI	121
	122	memset(&route,0,sizeof(route));
	123
f5174af2	124	if ((sid < ARRAY_SIZE(routing_schemes)) &&
a6a3a17b	125	((sp = routing_schemes + sid) != NULL) &&
f5174af2 MI	126	(hdw->input_val >= 0) &&
	127	(hdw->input_val < sp->cnt)) {
	128	vid_input = sp->def[hdw->input_val].vid;
	129	aud_input = sp->def[hdw->input_val].aud;
	130	} else {
	131	pvr2_trace(PVR2_TRACE_ERROR_LEGS,
	132	"* WARNING * i2c cx2584x set_input:"
	133	" Invalid routing scheme (%u) and/or input (%d)",
	134	sid,hdw->input_val);
	135	return;
d855497e MI	136	}
	137
	138	pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx2584x set_input vid=0x%x aud=0x%x",
	139	vid_input,aud_input);
	140	route.input = (u32)vid_input;
	141	pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_S_VIDEO_ROUTING,&route);
	142	route.input = (u32)aud_input;
	143	pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_S_AUDIO_ROUTING,&route);
	144	}
	145
	146
	147	static int check_input(struct pvr2_v4l_cx2584x *ctxt)
	148	{
	149	struct pvr2_hdw *hdw = ctxt->hdw;
	150	return hdw->input_dirty != 0;
	151	}
	152
	153
	154	static void set_audio(struct pvr2_v4l_cx2584x *ctxt)
	155	{
	156	u32 val;
	157	struct pvr2_hdw *hdw = ctxt->hdw;
	158
	159	pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx2584x set_audio %d",
	160	hdw->srate_val);
	161	switch (hdw->srate_val) {
	162	default:
b30d2441	163	case V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000:
d855497e MI	164	val = 48000;
d855497e MI	165	break;
b30d2441	166	case V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100:
d855497e MI	167	val = 44100;
d855497e MI	168	break;
b30d2441 MI	169	case V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000:
	170	val = 32000;
	171	break;
d855497e MI	172	}
	173	pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_AUDIO_CLOCK_FREQ,&val);
	174	}
	175
	176
	177	static int check_audio(struct pvr2_v4l_cx2584x *ctxt)
	178	{
	179	struct pvr2_hdw *hdw = ctxt->hdw;
	180	return hdw->srate_dirty != 0;
	181	}
	182
	183
	184	struct pvr2_v4l_cx2584x_ops {
	185	void (update)(struct pvr2_v4l_cx2584x );
	186	int (check)(struct pvr2_v4l_cx2584x );
	187	};
	188
	189
	190	static const struct pvr2_v4l_cx2584x_ops decoder_ops[] = {
	191	{ .update = set_input, .check = check_input},
	192	{ .update = set_audio, .check = check_audio},
	193	};
	194
	195
	196	static void decoder_detach(struct pvr2_v4l_cx2584x *ctxt)
	197	{
a0fd1cb1	198	ctxt->client->handler = NULL;
681c7399	199	pvr2_hdw_set_decoder(ctxt->hdw,NULL);
d855497e MI	200	kfree(ctxt);
	201	}
	202
	203
	204	static int decoder_check(struct pvr2_v4l_cx2584x *ctxt)
	205	{
	206	unsigned long msk;
	207	unsigned int idx;
	208
27c7b710	209	for (idx = 0; idx < ARRAY_SIZE(decoder_ops); idx++) {
d855497e MI	210	msk = 1 << idx;
	211	if (ctxt->stale_mask & msk) continue;
	212	if (decoder_ops[idx].check(ctxt)) {
	213	ctxt->stale_mask \|= msk;
	214	}
	215	}
	216	return ctxt->stale_mask != 0;
	217	}
	218
	219
	220	static void decoder_update(struct pvr2_v4l_cx2584x *ctxt)
	221	{
	222	unsigned long msk;
	223	unsigned int idx;
	224
27c7b710	225	for (idx = 0; idx < ARRAY_SIZE(decoder_ops); idx++) {
d855497e MI	226	msk = 1 << idx;
	227	if (!(ctxt->stale_mask & msk)) continue;
	228	ctxt->stale_mask &= ~msk;
	229	decoder_ops[idx].update(ctxt);
	230	}
	231	}
	232
	233
	234	static void decoder_enable(struct pvr2_v4l_cx2584x *ctxt,int fl)
	235	{
	236	pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx25840 decoder_enable(%d)",fl);
	237	pvr2_v4l2_cmd_stream(ctxt->client,fl);
	238	}
	239
	240
	241	static int decoder_detect(struct pvr2_i2c_client *cp)
	242	{
	243	int ret;
	244	/* Attempt to query the decoder - let's see if it will answer */
	245	struct v4l2_queryctrl qc;
	246
	247	memset(&qc,0,sizeof(qc));
	248
	249	qc.id = V4L2_CID_BRIGHTNESS;
	250
	251	ret = pvr2_i2c_client_cmd(cp,VIDIOC_QUERYCTRL,&qc);
	252	return ret == 0; /* Return true if it answered */
	253	}
	254
	255
d855497e MI	256	static unsigned int decoder_describe(struct pvr2_v4l_cx2584x *ctxt,
	257	char *buf,unsigned int cnt)
	258	{
	259	return scnprintf(buf,cnt,"handler: pvrusb2-cx2584x-v4l");
	260	}
	261
	262
	263	static void decoder_reset(struct pvr2_v4l_cx2584x *ctxt)
	264	{
	265	int ret;
c2625bff	266	ret = pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_RESET,NULL);
d855497e MI	267	pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx25840 decoder_reset (ret=%d)",ret);
	268	}
	269
	270
c5a69d57	271	static const struct pvr2_i2c_handler_functions hfuncs = {
d855497e MI	272	.detach = (void ()(void ))decoder_detach,
	273	.check = (int ()(void ))decoder_check,
	274	.update = (void ()(void ))decoder_update,
	275	.describe = (unsigned int ()(void ,char *,unsigned int))decoder_describe,
	276	};
	277
	278
	279	int pvr2_i2c_cx2584x_v4l_setup(struct pvr2_hdw *hdw,
	280	struct pvr2_i2c_client *cp)
	281	{
	282	struct pvr2_v4l_cx2584x *ctxt;
	283
	284	if (hdw->decoder_ctrl) return 0;
	285	if (cp->handler) return 0;
	286	if (!decoder_detect(cp)) return 0;
	287
ca545f7c	288	ctxt = kzalloc(sizeof(*ctxt),GFP_KERNEL);
d855497e	289	if (!ctxt) return 0;
d855497e MI	290
	291	ctxt->handler.func_data = ctxt;
	292	ctxt->handler.func_table = &hfuncs;
	293	ctxt->ctrl.ctxt = ctxt;
	294	ctxt->ctrl.detach = (void ()(void ))decoder_detach;
	295	ctxt->ctrl.enable = (void ()(void ,int))decoder_enable;
d855497e MI	296	ctxt->ctrl.force_reset = (void ()(void))decoder_reset;
	297	ctxt->client = cp;
	298	ctxt->hdw = hdw;
27c7b710	299	ctxt->stale_mask = (1 << ARRAY_SIZE(decoder_ops)) - 1;
681c7399	300	pvr2_hdw_set_decoder(hdw,&ctxt->ctrl);
d855497e	301	cp->handler = &ctxt->handler;
ff67c614 MI	302	{
	303	/*
	304	Mike Isely <isely@pobox.com> 19-Nov-2006 - This bit
	305	of nuttiness for cx25840 causes that module to
	306	correctly set up its video scaling. This is really
	307	a problem in the cx25840 module itself, but we work
	308	around it here. The problem has not been seen in
	309	ivtv because there VBI is supported and set up. We
	310	don't do VBI here (at least not yet) and thus we
	311	never attempted to even set it up.
	312	*/
	313	struct v4l2_format fmt;
	314	memset(&fmt,0,sizeof(fmt));
	315	fmt.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
	316	pvr2_i2c_client_cmd(ctxt->client,VIDIOC_S_FMT,&fmt);
	317	}
d855497e MI	318	pvr2_trace(PVR2_TRACE_CHIPS,"i2c 0x%x cx2584x V4L2 handler set up",
	319	cp->client->addr);
	320	return !0;
	321	}
	322
	323
	324
	325
	326	/*
	327	Stuff for Emacs to see, in order to encourage consistent editing style:
	328	* Local Variables: *
	329	* mode: c *
	330	* fill-column: 70 *
	331	* tab-width: 8 *
	332	* c-basic-offset: 8 *
	333	* End: *
	334	*/