[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 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),
	},
};

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;
};


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;
}


void pvr2_cx25840_subdev_update(struct pvr2_hdw *hdw, struct v4l2_subdev *sd)
{
	if (hdw->input_dirty) {
		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 *** subdev 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;
		sd->ops->video->s_routing(sd, &route);
		route.input = (u32)aud_input;
		sd->ops->audio->s_routing(sd, &route);
	}
}


/*
  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
d855497e	42
f5174af2 MI	43	struct routing_scheme_item {
	44	int vid;
	45	int aud;
	46	};
	47
	48	struct routing_scheme {
	49	const struct routing_scheme_item *def;
	50	unsigned int cnt;
	51	};
	52
	53	static const struct routing_scheme_item routing_scheme0[] = {
	54	[PVR2_CVAL_INPUT_TV] = {
	55	.vid = CX25840_COMPOSITE7,
	56	.aud = CX25840_AUDIO8,
	57	},
	58	[PVR2_CVAL_INPUT_RADIO] = { /* Treat the same as composite */
	59	.vid = CX25840_COMPOSITE3,
	60	.aud = CX25840_AUDIO_SERIAL,
	61	},
	62	[PVR2_CVAL_INPUT_COMPOSITE] = {
	63	.vid = CX25840_COMPOSITE3,
	64	.aud = CX25840_AUDIO_SERIAL,
	65	},
	66	[PVR2_CVAL_INPUT_SVIDEO] = {
	67	.vid = CX25840_SVIDEO1,
	68	.aud = CX25840_AUDIO_SERIAL,
	69	},
	70	};
	71
9e2e3aeb MI	72	/* Specific to gotview device */
	73	static const struct routing_scheme_item routing_schemegv[] = {
	74	[PVR2_CVAL_INPUT_TV] = {
	75	.vid = CX25840_COMPOSITE2,
	76	.aud = CX25840_AUDIO5,
	77	},
1df59f0b MI	78	[PVR2_CVAL_INPUT_RADIO] = {
	79	/* line-in is used for radio and composite. A GPIO is
	80	used to switch between the two choices. */
9e2e3aeb MI	81	.vid = CX25840_COMPOSITE1,
	82	.aud = CX25840_AUDIO_SERIAL,
	83	},
	84	[PVR2_CVAL_INPUT_COMPOSITE] = {
	85	.vid = CX25840_COMPOSITE1,
	86	.aud = CX25840_AUDIO_SERIAL,
	87	},
	88	[PVR2_CVAL_INPUT_SVIDEO] = {
	89	.vid = (CX25840_SVIDEO_LUMA3\|CX25840_SVIDEO_CHROMA4),
	90	.aud = CX25840_AUDIO_SERIAL,
	91	},
	92	};
	93
f5174af2 MI	94	static const struct routing_scheme routing_schemes[] = {
	95	[PVR2_ROUTING_SCHEME_HAUPPAUGE] = {
	96	.def = routing_scheme0,
	97	.cnt = ARRAY_SIZE(routing_scheme0),
	98	},
9e2e3aeb MI	99	[PVR2_ROUTING_SCHEME_GOTVIEW] = {
	100	.def = routing_schemegv,
	101	.cnt = ARRAY_SIZE(routing_schemegv),
	102	},
f5174af2 MI	103	};
f5174af2 MI	104
634ba268 MI	105	struct pvr2_v4l_cx2584x {
	106	struct pvr2_i2c_handler handler;
	107	struct pvr2_decoder_ctrl ctrl;
	108	struct pvr2_i2c_client *client;
	109	struct pvr2_hdw *hdw;
	110	unsigned long stale_mask;
	111	};
	112
	113
d855497e MI	114	static void set_input(struct pvr2_v4l_cx2584x *ctxt)
	115	{
	116	struct pvr2_hdw *hdw = ctxt->hdw;
	117	struct v4l2_routing route;
	118	enum cx25840_video_input vid_input;
	119	enum cx25840_audio_input aud_input;
f5174af2 MI	120	const struct routing_scheme *sp;
f5174af2 MI	121	unsigned int sid = hdw->hdw_desc->signal_routing_scheme;
d855497e MI	122
	123	memset(&route,0,sizeof(route));
	124
f5174af2	125	if ((sid < ARRAY_SIZE(routing_schemes)) &&
a6a3a17b	126	((sp = routing_schemes + sid) != NULL) &&
f5174af2 MI	127	(hdw->input_val >= 0) &&
	128	(hdw->input_val < sp->cnt)) {
	129	vid_input = sp->def[hdw->input_val].vid;
	130	aud_input = sp->def[hdw->input_val].aud;
	131	} else {
	132	pvr2_trace(PVR2_TRACE_ERROR_LEGS,
	133	"* WARNING * i2c cx2584x set_input:"
	134	" Invalid routing scheme (%u) and/or input (%d)",
	135	sid,hdw->input_val);
	136	return;
d855497e MI	137	}
	138
	139	pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx2584x set_input vid=0x%x aud=0x%x",
	140	vid_input,aud_input);
	141	route.input = (u32)vid_input;
	142	pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_S_VIDEO_ROUTING,&route);
	143	route.input = (u32)aud_input;
	144	pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_S_AUDIO_ROUTING,&route);
	145	}
	146
	147
	148	static int check_input(struct pvr2_v4l_cx2584x *ctxt)
	149	{
	150	struct pvr2_hdw *hdw = ctxt->hdw;
	151	return hdw->input_dirty != 0;
	152	}
	153
	154
	155	static void set_audio(struct pvr2_v4l_cx2584x *ctxt)
	156	{
	157	u32 val;
	158	struct pvr2_hdw *hdw = ctxt->hdw;
	159
	160	pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx2584x set_audio %d",
	161	hdw->srate_val);
	162	switch (hdw->srate_val) {
	163	default:
b30d2441	164	case V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000:
d855497e MI	165	val = 48000;
d855497e MI	166	break;
b30d2441	167	case V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100:
d855497e MI	168	val = 44100;
d855497e MI	169	break;
b30d2441 MI	170	case V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000:
	171	val = 32000;
	172	break;
d855497e MI	173	}
	174	pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_AUDIO_CLOCK_FREQ,&val);
	175	}
	176
	177
	178	static int check_audio(struct pvr2_v4l_cx2584x *ctxt)
	179	{
	180	struct pvr2_hdw *hdw = ctxt->hdw;
	181	return hdw->srate_dirty != 0;
	182	}
	183
	184
	185	struct pvr2_v4l_cx2584x_ops {
	186	void (update)(struct pvr2_v4l_cx2584x );
	187	int (check)(struct pvr2_v4l_cx2584x );
	188	};
	189
	190
	191	static const struct pvr2_v4l_cx2584x_ops decoder_ops[] = {
	192	{ .update = set_input, .check = check_input},
	193	{ .update = set_audio, .check = check_audio},
	194	};
	195
	196
	197	static void decoder_detach(struct pvr2_v4l_cx2584x *ctxt)
	198	{
a0fd1cb1	199	ctxt->client->handler = NULL;
681c7399	200	pvr2_hdw_set_decoder(ctxt->hdw,NULL);
d855497e MI	201	kfree(ctxt);
	202	}
	203
	204
	205	static int decoder_check(struct pvr2_v4l_cx2584x *ctxt)
	206	{
	207	unsigned long msk;
	208	unsigned int idx;
	209
27c7b710	210	for (idx = 0; idx < ARRAY_SIZE(decoder_ops); idx++) {
d855497e MI	211	msk = 1 << idx;
	212	if (ctxt->stale_mask & msk) continue;
	213	if (decoder_ops[idx].check(ctxt)) {
	214	ctxt->stale_mask \|= msk;
	215	}
	216	}
	217	return ctxt->stale_mask != 0;
	218	}
	219
	220
	221	static void decoder_update(struct pvr2_v4l_cx2584x *ctxt)
	222	{
	223	unsigned long msk;
	224	unsigned int idx;
	225
27c7b710	226	for (idx = 0; idx < ARRAY_SIZE(decoder_ops); idx++) {
d855497e MI	227	msk = 1 << idx;
	228	if (!(ctxt->stale_mask & msk)) continue;
	229	ctxt->stale_mask &= ~msk;
	230	decoder_ops[idx].update(ctxt);
	231	}
	232	}
	233
	234
	235	static void decoder_enable(struct pvr2_v4l_cx2584x *ctxt,int fl)
	236	{
	237	pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx25840 decoder_enable(%d)",fl);
	238	pvr2_v4l2_cmd_stream(ctxt->client,fl);
	239	}
	240
	241
	242	static int decoder_detect(struct pvr2_i2c_client *cp)
	243	{
	244	int ret;
	245	/* Attempt to query the decoder - let's see if it will answer */
	246	struct v4l2_queryctrl qc;
	247
	248	memset(&qc,0,sizeof(qc));
	249
	250	qc.id = V4L2_CID_BRIGHTNESS;
	251
	252	ret = pvr2_i2c_client_cmd(cp,VIDIOC_QUERYCTRL,&qc);
	253	return ret == 0; /* Return true if it answered */
	254	}
	255
	256
d855497e MI	257	static unsigned int decoder_describe(struct pvr2_v4l_cx2584x *ctxt,
	258	char *buf,unsigned int cnt)
	259	{
	260	return scnprintf(buf,cnt,"handler: pvrusb2-cx2584x-v4l");
	261	}
	262
	263
	264	static void decoder_reset(struct pvr2_v4l_cx2584x *ctxt)
	265	{
	266	int ret;
c2625bff	267	ret = pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_RESET,NULL);
d855497e MI	268	pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx25840 decoder_reset (ret=%d)",ret);
	269	}
	270
	271
c5a69d57	272	static const struct pvr2_i2c_handler_functions hfuncs = {
d855497e MI	273	.detach = (void ()(void ))decoder_detach,
	274	.check = (int ()(void ))decoder_check,
	275	.update = (void ()(void ))decoder_update,
	276	.describe = (unsigned int ()(void ,char *,unsigned int))decoder_describe,
	277	};
	278
	279
	280	int pvr2_i2c_cx2584x_v4l_setup(struct pvr2_hdw *hdw,
	281	struct pvr2_i2c_client *cp)
	282	{
	283	struct pvr2_v4l_cx2584x *ctxt;
	284
	285	if (hdw->decoder_ctrl) return 0;
	286	if (cp->handler) return 0;
	287	if (!decoder_detect(cp)) return 0;
	288
ca545f7c	289	ctxt = kzalloc(sizeof(*ctxt),GFP_KERNEL);
d855497e	290	if (!ctxt) return 0;
d855497e MI	291
	292	ctxt->handler.func_data = ctxt;
	293	ctxt->handler.func_table = &hfuncs;
	294	ctxt->ctrl.ctxt = ctxt;
	295	ctxt->ctrl.detach = (void ()(void ))decoder_detach;
	296	ctxt->ctrl.enable = (void ()(void ,int))decoder_enable;
d855497e MI	297	ctxt->ctrl.force_reset = (void ()(void))decoder_reset;
	298	ctxt->client = cp;
	299	ctxt->hdw = hdw;
27c7b710	300	ctxt->stale_mask = (1 << ARRAY_SIZE(decoder_ops)) - 1;
681c7399	301	pvr2_hdw_set_decoder(hdw,&ctxt->ctrl);
d855497e	302	cp->handler = &ctxt->handler;
ff67c614 MI	303	{
	304	/*
	305	Mike Isely <isely@pobox.com> 19-Nov-2006 - This bit
	306	of nuttiness for cx25840 causes that module to
	307	correctly set up its video scaling. This is really
	308	a problem in the cx25840 module itself, but we work
	309	around it here. The problem has not been seen in
	310	ivtv because there VBI is supported and set up. We
	311	don't do VBI here (at least not yet) and thus we
	312	never attempted to even set it up.
	313	*/
	314	struct v4l2_format fmt;
	315	memset(&fmt,0,sizeof(fmt));
	316	fmt.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
	317	pvr2_i2c_client_cmd(ctxt->client,VIDIOC_S_FMT,&fmt);
	318	}
d855497e MI	319	pvr2_trace(PVR2_TRACE_CHIPS,"i2c 0x%x cx2584x V4L2 handler set up",
	320	cp->client->addr);
	321	return !0;
	322	}
	323
	324
634ba268 MI	325	void pvr2_cx25840_subdev_update(struct pvr2_hdw hdw, struct v4l2_subdev sd)
	326	{
	327	if (hdw->input_dirty) {
	328	struct v4l2_routing route;
	329	enum cx25840_video_input vid_input;
	330	enum cx25840_audio_input aud_input;
	331	const struct routing_scheme *sp;
	332	unsigned int sid = hdw->hdw_desc->signal_routing_scheme;
	333
	334	memset(&route, 0, sizeof(route));
	335
	336	if ((sid < ARRAY_SIZE(routing_schemes)) &&
	337	((sp = routing_schemes + sid) != NULL) &&
	338	(hdw->input_val >= 0) &&
	339	(hdw->input_val < sp->cnt)) {
	340	vid_input = sp->def[hdw->input_val].vid;
	341	aud_input = sp->def[hdw->input_val].aud;
	342	} else {
	343	pvr2_trace(PVR2_TRACE_ERROR_LEGS,
	344	"* WARNING * subdev cx2584x set_input:"
	345	" Invalid routing scheme (%u)"
	346	" and/or input (%d)",
	347	sid, hdw->input_val);
	348	return;
	349	}
	350
	351	pvr2_trace(PVR2_TRACE_CHIPS,
	352	"i2c cx2584x set_input vid=0x%x aud=0x%x",
	353	vid_input, aud_input);
	354	route.input = (u32)vid_input;
	355	sd->ops->video->s_routing(sd, &route);
	356	route.input = (u32)aud_input;
	357	sd->ops->audio->s_routing(sd, &route);
	358	}
	359	}
d855497e MI	360
d855497e MI	361
acd92d40	362
d855497e MI	363	/*
	364	Stuff for Emacs to see, in order to encourage consistent editing style:
	365	* Local Variables: *
	366	* mode: c *
	367	* fill-column: 70 *
	368	* tab-width: 8 *
	369	* c-basic-offset: 8 *
	370	* End: *
	371	*/