WebSVN - shark - Blame - Rev 752 - /shark/trunk/drivers/bttv/bttv-driver.c

Rev	Author	Line No.	Line
170	giacomo	1	/*
		2	bttv - Bt848 frame grabber driver
428	giacomo	3
		4	Copyright (C) 1996,97,98 Ralph Metzler <rjkm@thp.uni-koeln.de>
		5	& Marcus Metzler <mocm@thp.uni-koeln.de>
		6	(c) 1999-2002 Gerd Knorr <kraxel@bytesex.org>
		7
		8	some v4l2 code lines are taken from Justin's bttv2 driver which is
		9	(c) 2000 Justin Schoeman <justin@suntiger.ee.up.ac.za>
		10
170	giacomo	11	This program is free software; you can redistribute it and/or modify
		12	it under the terms of the GNU General Public License as published by
		13	the Free Software Foundation; either version 2 of the License, or
		14	(at your option) any later version.
428	giacomo	15
170	giacomo	16	This program is distributed in the hope that it will be useful,
		17	but WITHOUT ANY WARRANTY; without even the implied warranty of
		18	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		19	GNU General Public License for more details.
428	giacomo	20
170	giacomo	21	You should have received a copy of the GNU General Public License
		22	along with this program; if not, write to the Free Software
		23	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
		24	*/
		25
428	giacomo	26	#include <linuxcomp.h>
170	giacomo	27
428	giacomo	28	#include <linux/init.h>
		29	#include <linux/module.h>
		30	#include <linux/delay.h>
		31	#include <linux/errno.h>
		32	#include <linux/fs.h>
		33	#include <linux/kernel.h>
		34	#include <linux/sched.h>
		35	#include <linux/interrupt.h>
		36	#include <linux/kdev_t.h>
170	giacomo	37
428	giacomo	38	#include <asm/io.h>
		39	#include <asm/byteorder.h>
170	giacomo	40
428	giacomo	41	#include "drivers/bttvp.h"
170	giacomo	42
428	giacomo	43	unsigned int bttv_num; /* number of Bt848s in use */
		44	struct bttv bttvs[BTTV_MAX];
170	giacomo	45
614	giacomo	46	unsigned int bttv_debug = 0;
428	giacomo	47	unsigned int bttv_verbose = 1;
614	giacomo	48	unsigned int bttv_gpio = 0;
170	giacomo	49
428	giacomo	50	/* config variables */
		51	#ifdef __BIG_ENDIAN
170	giacomo	52	static unsigned int bigendian=1;
		53	#else
		54	static unsigned int bigendian=0;
		55	#endif
		56	static unsigned int radio[BTTV_MAX];
		57	static unsigned int irq_debug = 0;
428	giacomo	58	static unsigned int gbuffers = 8;
		59	static unsigned int gbufsize = 0x208000;
170	giacomo	60
541	giacomo	61	static int video_nr = -1;
		62	static int radio_nr = -1;
516	giacomo	63	//static int vbi_nr = -1;
170	giacomo	64
428	giacomo	65	static unsigned int fdsr = 0;
170	giacomo	66
428	giacomo	67	/* options */
		68	static unsigned int combfilter = 0;
		69	static unsigned int lumafilter = 0;
		70	static unsigned int automute = 1;
		71	static unsigned int chroma_agc = 0;
		72	static unsigned int adc_crush = 1;
		73	static unsigned int vcr_hack = 0;
		74	static unsigned int irq_iswitch = 0;
170	giacomo	75
428	giacomo	76	/* API features (turn on/off stuff for testing) */
		77	static unsigned int sloppy = 0;
		78	static unsigned int v4l2 = 1;
170	giacomo	79
696	giacomo	80	static volatile unsigned int grab_task = -1;
170	giacomo	81
428	giacomo	82	/* insmod args */
		83	MODULE_PARM(radio,"1-" __stringify(BTTV_MAX) "i");
		84	MODULE_PARM_DESC(radio,"The TV card supports radio, default is 0 (no)");
		85	MODULE_PARM(bigendian,"i");
		86	MODULE_PARM_DESC(bigendian,"byte order of the framebuffer, default is native endian");
		87	MODULE_PARM(bttv_verbose,"i");
		88	MODULE_PARM_DESC(bttv_verbose,"verbose startup messages, default is 1 (yes)");
		89	MODULE_PARM(bttv_gpio,"i");
		90	MODULE_PARM_DESC(bttv_gpio,"log gpio changes, default is 0 (no)");
		91	MODULE_PARM(bttv_debug,"i");
		92	MODULE_PARM_DESC(bttv_debug,"debug messages, default is 0 (no)");
		93	MODULE_PARM(irq_debug,"i");
		94	MODULE_PARM_DESC(irq_debug,"irq handler debug messages, default is 0 (no)");
		95	MODULE_PARM(gbuffers,"i");
		96	MODULE_PARM_DESC(gbuffers,"number of capture buffers. range 2-32, default 8");
		97	MODULE_PARM(gbufsize,"i");
		98	MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 0x208000");
170	giacomo	99
428	giacomo	100	MODULE_PARM(video_nr,"i");
		101	MODULE_PARM(radio_nr,"i");
		102	MODULE_PARM(vbi_nr,"i");
170	giacomo	103
428	giacomo	104	MODULE_PARM(fdsr,"i");
170	giacomo	105
428	giacomo	106	MODULE_PARM(combfilter,"i");
		107	MODULE_PARM(lumafilter,"i");
		108	MODULE_PARM(automute,"i");
		109	MODULE_PARM_DESC(automute,"mute audio on bad/missing video signal, default is 1 (yes)");
		110	MODULE_PARM(chroma_agc,"i");
		111	MODULE_PARM_DESC(chroma_agc,"enables the AGC of chroma signal, default is 0 (no)");
		112	MODULE_PARM(adc_crush,"i");
		113	MODULE_PARM_DESC(adc_crush,"enables the luminance ADC crush, default is 1 (yes)");
		114	MODULE_PARM(vcr_hack,"i");
		115	MODULE_PARM_DESC(vcr_hack,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
		116	MODULE_PARM(irq_iswitch,"i");
		117	MODULE_PARM_DESC(irq_iswitch,"switch inputs in irq handler");
170	giacomo	118
428	giacomo	119	MODULE_PARM(sloppy,"i");
		120	MODULE_PARM(v4l2,"i");
170	giacomo	121
428	giacomo	122	MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
		123	MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
		124	MODULE_LICENSE("GPL");
170	giacomo	125
428	giacomo	126	/* kernel args */
		127	#ifndef MODULE
		128	static int __init p_radio(char *str) { return bttv_parse(str,BTTV_MAX,radio); }
		129	__setup("bttv.radio=", p_radio);
		130	#endif
		131
		132	/* ----------------------------------------------------------------------- */
		133	/* sysfs */
516	giacomo	134	/*
428	giacomo	135	static ssize_t show_card(struct class_device cd, char buf)
170	giacomo	136	{
428	giacomo	137	struct video_device *vfd = to_video_device(cd);
		138	struct bttv *btv = dev_get_drvdata(vfd->dev);
463	giacomo	139	return sprintf26(buf, "%d\n", btv ? btv->type : UNSET);
170	giacomo	140	}
516	giacomo	141	*/
		142	//static CLASS_DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
170	giacomo	143
428	giacomo	144	/* ----------------------------------------------------------------------- */
		145	/* static data */
		146
		147	/* special timing tables from conexant... */
		148	static u8 SRAM_Table[][60] =
170	giacomo	149	{
428	giacomo	150	/* PAL digital input over GPIO[7:0] */
		151	{
		152	45, // 45 bytes following
		153	0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
		154	0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
		155	0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
		156	0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
		157	0x37,0x00,0xAF,0x21,0x00
		158	},
		159	/* NTSC digital input over GPIO[7:0] */
		160	{
		161	51, // 51 bytes following
		162	0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
		163	0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
		164	0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
		165	0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
		166	0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
		167	0x00,
		168	},
		169	// TGB_NTSC392 // quartzsight
		170	// This table has been modified to be used for Fusion Rev D
		171	{
		172	0x2A, // size of table = 42
		173	0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
		174	0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
		175	0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
		176	0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
		177	0x20, 0x00
		178	}
		179	};
170	giacomo	180
428	giacomo	181	const struct bttv_tvnorm bttv_tvnorms[] = {
		182	/* PAL-BDGHI */
		183	/* max. active video is actually 922, but 924 is divisible by 4 and 3! */
		184	/* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
		185	{
		186	.v4l2_id = V4L2_STD_PAL,
		187	.name = "PAL",
		188	.Fsc = 35468950,
		189	.swidth = 924,
		190	.sheight = 576,
		191	.totalwidth = 1135,
		192	.adelay = 0x7f,
		193	.bdelay = 0x72,
		194	.iform = (BT848_IFORM_PAL_BDGHI\|BT848_IFORM_XT1),
		195	.scaledtwidth = 1135,
		196	.hdelayx1 = 186,
		197	.hactivex1 = 924,
		198	.vdelay = 0x20,
		199	.vbipack = 255,
		200	.sram = 0,
		201	},{
		202	.v4l2_id = V4L2_STD_NTSC_M,
		203	.name = "NTSC",
		204	.Fsc = 28636363,
		205	.swidth = 768,
		206	.sheight = 480,
		207	.totalwidth = 910,
		208	.adelay = 0x68,
		209	.bdelay = 0x5d,
		210	.iform = (BT848_IFORM_NTSC\|BT848_IFORM_XT0),
		211	.scaledtwidth = 910,
		212	.hdelayx1 = 128,
		213	.hactivex1 = 910,
		214	.vdelay = 0x1a,
		215	.vbipack = 144,
		216	.sram = 1,
		217	},{
		218	.v4l2_id = V4L2_STD_SECAM,
		219	.name = "SECAM",
		220	.Fsc = 35468950,
		221	.swidth = 924,
		222	.sheight = 576,
		223	.totalwidth = 1135,
		224	.adelay = 0x7f,
		225	.bdelay = 0xb0,
		226	.iform = (BT848_IFORM_SECAM\|BT848_IFORM_XT1),
		227	.scaledtwidth = 1135,
		228	.hdelayx1 = 186,
		229	.hactivex1 = 922,
		230	.vdelay = 0x20,
		231	.vbipack = 255,
		232	.sram = 0, /* like PAL, correct? */
		233	},{
		234	.v4l2_id = V4L2_STD_PAL_Nc,
		235	.name = "PAL-Nc",
		236	.Fsc = 28636363,
		237	.swidth = 640,
		238	.sheight = 576,
		239	.totalwidth = 910,
		240	.adelay = 0x68,
		241	.bdelay = 0x5d,
		242	.iform = (BT848_IFORM_PAL_NC\|BT848_IFORM_XT0),
		243	.scaledtwidth = 780,
		244	.hdelayx1 = 130,
		245	.hactivex1 = 734,
		246	.vdelay = 0x1a,
		247	.vbipack = 144,
		248	.sram = -1,
		249	},{
		250	.v4l2_id = V4L2_STD_PAL_M,
		251	.name = "PAL-M",
		252	.Fsc = 28636363,
		253	.swidth = 640,
		254	.sheight = 480,
		255	.totalwidth = 910,
		256	.adelay = 0x68,
		257	.bdelay = 0x5d,
		258	.iform = (BT848_IFORM_PAL_M\|BT848_IFORM_XT0),
		259	.scaledtwidth = 780,
		260	.hdelayx1 = 135,
		261	.hactivex1 = 754,
		262	.vdelay = 0x1a,
		263	.vbipack = 144,
		264	.sram = -1,
		265	},{
		266	.v4l2_id = V4L2_STD_PAL_N,
		267	.name = "PAL-N",
		268	.Fsc = 35468950,
		269	.swidth = 768,
		270	.sheight = 576,
		271	.totalwidth = 1135,
		272	.adelay = 0x7f,
		273	.bdelay = 0x72,
		274	.iform = (BT848_IFORM_PAL_N\|BT848_IFORM_XT1),
		275	.scaledtwidth = 944,
		276	.hdelayx1 = 186,
		277	.hactivex1 = 922,
		278	.vdelay = 0x20,
		279	.vbipack = 144,
		280	.sram = -1,
		281	},{
		282	.v4l2_id = V4L2_STD_NTSC_M_JP,
		283	.name = "NTSC-JP",
		284	.Fsc = 28636363,
		285	.swidth = 640,
		286	.sheight = 480,
		287	.totalwidth = 910,
		288	.adelay = 0x68,
		289	.bdelay = 0x5d,
		290	.iform = (BT848_IFORM_NTSC_J\|BT848_IFORM_XT0),
		291	.scaledtwidth = 780,
		292	.hdelayx1 = 135,
		293	.hactivex1 = 754,
		294	.vdelay = 0x16,
		295	.vbipack = 144,
		296	.sram = -1,
		297	},{
		298	/* that one hopefully works with the strange timing
		299	* which video recorders produce when playing a NTSC
		300	* tape on a PAL TV ... */
		301	.v4l2_id = V4L2_STD_PAL_60,
		302	.name = "PAL-60",
		303	.Fsc = 35468950,
		304	.swidth = 924,
		305	.sheight = 480,
		306	.totalwidth = 1135,
		307	.adelay = 0x7f,
		308	.bdelay = 0x72,
		309	.iform = (BT848_IFORM_PAL_BDGHI\|BT848_IFORM_XT1),
		310	.scaledtwidth = 1135,
		311	.hdelayx1 = 186,
		312	.hactivex1 = 924,
		313	.vdelay = 0x1a,
		314	.vbipack = 255,
		315	.vtotal = 524,
		316	.sram = -1,
		317	}
		318	};
		319	const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
170	giacomo	320
428	giacomo	321	/* ----------------------------------------------------------------------- */
		322	/* bttv format list
		323	packed pixel formats must come first */
		324	const struct bttv_format bttv_formats[] = {
		325	{
		326	.name = "8 bpp, gray",
		327	.palette = VIDEO_PALETTE_GREY,
		328	.fourcc = V4L2_PIX_FMT_GREY,
		329	.btformat = BT848_COLOR_FMT_Y8,
		330	.depth = 8,
		331	.flags = FORMAT_FLAGS_PACKED,
		332	},{
		333	.name = "8 bpp, dithered color",
		334	.palette = VIDEO_PALETTE_HI240,
		335	.fourcc = V4L2_PIX_FMT_HI240,
		336	.btformat = BT848_COLOR_FMT_RGB8,
		337	.depth = 8,
		338	.flags = FORMAT_FLAGS_PACKED \| FORMAT_FLAGS_DITHER,
		339	},{
		340	.name = "15 bpp RGB, le",
		341	.palette = VIDEO_PALETTE_RGB555,
		342	.fourcc = V4L2_PIX_FMT_RGB555,
		343	.btformat = BT848_COLOR_FMT_RGB15,
		344	.depth = 16,
		345	.flags = FORMAT_FLAGS_PACKED,
		346	},{
		347	.name = "15 bpp RGB, be",
		348	.palette = -1,
		349	.fourcc = V4L2_PIX_FMT_RGB555X,
		350	.btformat = BT848_COLOR_FMT_RGB15,
		351	.btswap = 0x03, /* byteswap */
		352	.depth = 16,
		353	.flags = FORMAT_FLAGS_PACKED,
		354	},{
		355	.name = "16 bpp RGB, le",
		356	.palette = VIDEO_PALETTE_RGB565,
		357	.fourcc = V4L2_PIX_FMT_RGB565,
		358	.btformat = BT848_COLOR_FMT_RGB16,
		359	.depth = 16,
		360	.flags = FORMAT_FLAGS_PACKED,
		361	},{
		362	.name = "16 bpp RGB, be",
		363	.palette = -1,
		364	.fourcc = V4L2_PIX_FMT_RGB565X,
		365	.btformat = BT848_COLOR_FMT_RGB16,
		366	.btswap = 0x03, /* byteswap */
		367	.depth = 16,
		368	.flags = FORMAT_FLAGS_PACKED,
		369	},{
		370	.name = "24 bpp RGB, le",
		371	.palette = VIDEO_PALETTE_RGB24,
		372	.fourcc = V4L2_PIX_FMT_BGR24,
		373	.btformat = BT848_COLOR_FMT_RGB24,
		374	.depth = 24,
		375	.flags = FORMAT_FLAGS_PACKED,
		376	},{
		377	.name = "32 bpp RGB, le",
		378	.palette = VIDEO_PALETTE_RGB32,
		379	.fourcc = V4L2_PIX_FMT_BGR32,
		380	.btformat = BT848_COLOR_FMT_RGB32,
		381	.depth = 32,
		382	.flags = FORMAT_FLAGS_PACKED,
		383	},{
		384	.name = "32 bpp RGB, be",
		385	.palette = -1,
		386	.fourcc = V4L2_PIX_FMT_RGB32,
		387	.btformat = BT848_COLOR_FMT_RGB32,
		388	.btswap = 0x0f, /* byte+word swap */
		389	.depth = 32,
		390	.flags = FORMAT_FLAGS_PACKED,
		391	},{
		392	.name = "4:2:2, packed, YUYV",
		393	.palette = VIDEO_PALETTE_YUV422,
		394	.fourcc = V4L2_PIX_FMT_YUYV,
		395	.btformat = BT848_COLOR_FMT_YUY2,
		396	.depth = 16,
		397	.flags = FORMAT_FLAGS_PACKED,
		398	},{
		399	.name = "4:2:2, packed, YUYV",
		400	.palette = VIDEO_PALETTE_YUYV,
		401	.fourcc = V4L2_PIX_FMT_YUYV,
		402	.btformat = BT848_COLOR_FMT_YUY2,
		403	.depth = 16,
		404	.flags = FORMAT_FLAGS_PACKED,
		405	},{
		406	.name = "4:2:2, packed, UYVY",
		407	.palette = VIDEO_PALETTE_UYVY,
		408	.fourcc = V4L2_PIX_FMT_UYVY,
		409	.btformat = BT848_COLOR_FMT_YUY2,
		410	.btswap = 0x03, /* byteswap */
		411	.depth = 16,
		412	.flags = FORMAT_FLAGS_PACKED,
		413	},{
		414	.name = "4:2:2, planar, Y-Cb-Cr",
		415	.palette = VIDEO_PALETTE_YUV422P,
		416	.fourcc = V4L2_PIX_FMT_YUV422P,
		417	.btformat = BT848_COLOR_FMT_YCrCb422,
		418	.depth = 16,
		419	.flags = FORMAT_FLAGS_PLANAR,
		420	.hshift = 1,
		421	.vshift = 0,
		422	},{
		423	.name = "4:2:0, planar, Y-Cb-Cr",
		424	.palette = VIDEO_PALETTE_YUV420P,
		425	.fourcc = V4L2_PIX_FMT_YUV420,
		426	.btformat = BT848_COLOR_FMT_YCrCb422,
		427	.depth = 12,
		428	.flags = FORMAT_FLAGS_PLANAR,
		429	.hshift = 1,
		430	.vshift = 1,
		431	},{
		432	.name = "4:2:0, planar, Y-Cr-Cb",
		433	.palette = -1,
		434	.fourcc = V4L2_PIX_FMT_YVU420,
		435	.btformat = BT848_COLOR_FMT_YCrCb422,
		436	.depth = 12,
		437	.flags = FORMAT_FLAGS_PLANAR \| FORMAT_FLAGS_CrCb,
		438	.hshift = 1,
		439	.vshift = 1,
		440	},{
		441	.name = "4:1:1, planar, Y-Cb-Cr",
		442	.palette = VIDEO_PALETTE_YUV411P,
		443	.fourcc = V4L2_PIX_FMT_YUV411P,
		444	.btformat = BT848_COLOR_FMT_YCrCb411,
		445	.depth = 12,
		446	.flags = FORMAT_FLAGS_PLANAR,
		447	.hshift = 2,
		448	.vshift = 0,
		449	},{
		450	.name = "4:1:0, planar, Y-Cb-Cr",
		451	.palette = VIDEO_PALETTE_YUV410P,
		452	.fourcc = V4L2_PIX_FMT_YUV410,
		453	.btformat = BT848_COLOR_FMT_YCrCb411,
		454	.depth = 9,
		455	.flags = FORMAT_FLAGS_PLANAR,
		456	.hshift = 2,
		457	.vshift = 2,
		458	},{
		459	.name = "4:1:0, planar, Y-Cr-Cb",
		460	.palette = -1,
		461	.fourcc = V4L2_PIX_FMT_YVU410,
		462	.btformat = BT848_COLOR_FMT_YCrCb411,
		463	.depth = 9,
		464	.flags = FORMAT_FLAGS_PLANAR \| FORMAT_FLAGS_CrCb,
		465	.hshift = 2,
		466	.vshift = 2,
		467	},{
		468	.name = "raw scanlines",
		469	.palette = VIDEO_PALETTE_RAW,
		470	.fourcc = -1,
		471	.btformat = BT848_COLOR_FMT_RAW,
		472	.depth = 8,
		473	.flags = FORMAT_FLAGS_RAW,
		474	}
		475	};
		476	const unsigned int BTTV_FORMATS = ARRAY_SIZE(bttv_formats);
170	giacomo	477
428	giacomo	478	/* ----------------------------------------------------------------------- */
		479
		480	#define V4L2_CID_PRIVATE_CHROMA_AGC (V4L2_CID_PRIVATE_BASE + 0)
		481	#define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_PRIVATE_BASE + 1)
		482	#define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_PRIVATE_BASE + 2)
		483	#define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_PRIVATE_BASE + 3)
		484	#define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_PRIVATE_BASE + 4)
		485	#define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_PRIVATE_BASE + 5)
		486	#define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 6)
		487
		488	static const struct v4l2_queryctrl no_ctl = {
		489	.name = "42",
		490	.flags = V4L2_CTRL_FLAG_DISABLED,
		491	};
		492	static const struct v4l2_queryctrl bttv_ctls[] = {
		493	/* --- video --- */
		494	{
		495	.id = V4L2_CID_BRIGHTNESS,
		496	.name = "Brightness",
		497	.minimum = 0,
		498	.maximum = 65535,
		499	.step = 256,
		500	.default_value = 32768,
		501	.type = V4L2_CTRL_TYPE_INTEGER,
		502	},{
		503	.id = V4L2_CID_CONTRAST,
		504	.name = "Contrast",
		505	.minimum = 0,
		506	.maximum = 65535,
		507	.step = 128,
		508	.default_value = 32768,
		509	.type = V4L2_CTRL_TYPE_INTEGER,
		510	},{
		511	.id = V4L2_CID_SATURATION,
		512	.name = "Saturation",
		513	.minimum = 0,
		514	.maximum = 65535,
		515	.step = 128,
		516	.default_value = 32768,
		517	.type = V4L2_CTRL_TYPE_INTEGER,
		518	},{
		519	.id = V4L2_CID_HUE,
		520	.name = "Hue",
		521	.minimum = 0,
		522	.maximum = 65535,
		523	.step = 256,
		524	.default_value = 32768,
		525	.type = V4L2_CTRL_TYPE_INTEGER,
		526	},
		527	/* --- audio --- */
		528	{
		529	.id = V4L2_CID_AUDIO_MUTE,
		530	.name = "Mute",
		531	.minimum = 0,
		532	.maximum = 1,
		533	.type = V4L2_CTRL_TYPE_BOOLEAN,
		534	},{
		535	.id = V4L2_CID_AUDIO_VOLUME,
		536	.name = "Volume",
		537	.minimum = 0,
		538	.maximum = 65535,
		539	.step = 65535/100,
		540	.default_value = 65535,
		541	.type = V4L2_CTRL_TYPE_INTEGER,
		542	},{
		543	.id = V4L2_CID_AUDIO_BALANCE,
		544	.name = "Balance",
		545	.minimum = 0,
		546	.maximum = 65535,
		547	.step = 65535/100,
		548	.default_value = 32768,
		549	.type = V4L2_CTRL_TYPE_INTEGER,
		550	},{
		551	.id = V4L2_CID_AUDIO_BASS,
		552	.name = "Bass",
		553	.minimum = 0,
		554	.maximum = 65535,
		555	.step = 65535/100,
		556	.default_value = 32768,
		557	.type = V4L2_CTRL_TYPE_INTEGER,
		558	},{
		559	.id = V4L2_CID_AUDIO_TREBLE,
		560	.name = "Treble",
		561	.minimum = 0,
		562	.maximum = 65535,
		563	.step = 65535/100,
		564	.default_value = 32768,
		565	.type = V4L2_CTRL_TYPE_INTEGER,
		566	},
		567	/* --- private --- */
		568	{
		569	.id = V4L2_CID_PRIVATE_CHROMA_AGC,
		570	.name = "chroma agc",
		571	.minimum = 0,
		572	.maximum = 1,
		573	.type = V4L2_CTRL_TYPE_BOOLEAN,
		574	},{
		575	.id = V4L2_CID_PRIVATE_COMBFILTER,
		576	.name = "combfilter",
		577	.minimum = 0,
		578	.maximum = 1,
		579	.type = V4L2_CTRL_TYPE_BOOLEAN,
		580	},{
		581	.id = V4L2_CID_PRIVATE_AUTOMUTE,
		582	.name = "automute",
		583	.minimum = 0,
		584	.maximum = 1,
		585	.type = V4L2_CTRL_TYPE_BOOLEAN,
		586	},{
		587	.id = V4L2_CID_PRIVATE_LUMAFILTER,
		588	.name = "luma decimation filter",
		589	.minimum = 0,
		590	.maximum = 1,
		591	.type = V4L2_CTRL_TYPE_BOOLEAN,
		592	},{
		593	.id = V4L2_CID_PRIVATE_AGC_CRUSH,
		594	.name = "agc crush",
		595	.minimum = 0,
		596	.maximum = 1,
		597	.type = V4L2_CTRL_TYPE_BOOLEAN,
		598	},{
		599	.id = V4L2_CID_PRIVATE_VCR_HACK,
		600	.name = "vcr hack",
		601	.minimum = 0,
		602	.maximum = 1,
		603	.type = V4L2_CTRL_TYPE_BOOLEAN,
		604	}
		605	};
		606	const int BTTV_CTLS = ARRAY_SIZE(bttv_ctls);
		607
		608	/* ----------------------------------------------------------------------- */
		609	/* resource management */
		610
		611	static
		612	int check_alloc_btres(struct bttv btv, struct bttv_fh fh, int bit)
170	giacomo	613	{
428	giacomo	614	if (fh->resources & bit)
		615	/* have it already allocated */
		616	return 1;
170	giacomo	617
428	giacomo	618	/* is it free? */
480	giacomo	619	//down(&btv->reslock);
428	giacomo	620	if (btv->resources & bit) {
		621	/* no, someone else uses it */
480	giacomo	622	//up(&btv->reslock);
428	giacomo	623	return 0;
		624	}
		625	/* it's free, grab it */
		626	fh->resources \|= bit;
		627	btv->resources \|= bit;
480	giacomo	628	//up(&btv->reslock);
428	giacomo	629	return 1;
		630	}
170	giacomo	631
428	giacomo	632	static
		633	int check_btres(struct bttv_fh *fh, int bit)
		634	{
		635	return (fh->resources & bit);
170	giacomo	636	}
		637
428	giacomo	638	static
		639	int locked_btres(struct bttv *btv, int bit)
170	giacomo	640	{
428	giacomo	641	return (btv->resources & bit);
170	giacomo	642	}
		643
428	giacomo	644	static
		645	void free_btres(struct bttv btv, struct bttv_fh fh, int bits)
170	giacomo	646	{
428	giacomo	647	#if 1 /* DEBUG */
		648	if ((fh->resources & bits) != bits) {
		649	/* trying to free ressources not allocated by us ... */
		650	printk("bttv: BUG! (btres)\n");
		651	}
		652	#endif
480	giacomo	653	//down(&btv->reslock);
428	giacomo	654	fh->resources &= ~bits;
		655	btv->resources &= ~bits;
480	giacomo	656	//up(&btv->reslock);
170	giacomo	657	}
		658
428	giacomo	659	/* ----------------------------------------------------------------------- */
		660	/* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */
170	giacomo	661
		662	/* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
		663	PLL_X = Reference pre-divider (0=1, 1=2)
		664	PLL_C = Post divider (0=6, 1=4)
		665	PLL_I = Integer input
		666	PLL_F = Fractional input
		667
		668	F_input = 28.636363 MHz:
		669	PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
		670	*/
		671
		672	static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
		673	{
		674	unsigned char fl, fh, fi;
		675
		676	/* prevent overflows */
		677	fin/=4;
		678	fout/=4;
		679
		680	fout*=12;
		681	fi=fout/fin;
		682
		683	fout=(fout%fin)*256;
		684	fh=fout/fin;
		685
		686	fout=(fout%fin)*256;
		687	fl=fout/fin;
		688
		689	btwrite(fl, BT848_PLL_F_LO);
		690	btwrite(fh, BT848_PLL_F_HI);
		691	btwrite(fi\|BT848_PLL_X, BT848_PLL_XCI);
		692	}
		693
428	giacomo	694	static void set_pll(struct bttv *btv)
170	giacomo	695	{
		696	int i;
		697
		698	if (!btv->pll.pll_crystal)
428	giacomo	699	return;
170	giacomo	700
428	giacomo	701	if (btv->pll.pll_ofreq == btv->pll.pll_current) {
		702	dprintk("bttv%d: PLL: no change required\n",btv->nr);
		703	return;
		704	}
		705
170	giacomo	706	if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
		707	/* no PLL needed */
428	giacomo	708	if (btv->pll.pll_current == 0)
		709	return;
		710	vprintk(KERN_INFO "bttv%d: PLL can sleep, using XTAL (%d).\n",
		711	btv->nr,btv->pll.pll_ifreq);
170	giacomo	712	btwrite(0x00,BT848_TGCTRL);
		713	btwrite(0x00,BT848_PLL_XCI);
		714	btv->pll.pll_current = 0;
428	giacomo	715	return;
170	giacomo	716	}
		717
428	giacomo	718	vprintk(KERN_INFO "bttv%d: PLL: %d => %d ",btv->nr,
		719	btv->pll.pll_ifreq, btv->pll.pll_ofreq);
170	giacomo	720	set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
		721
428	giacomo	722	for (i=0; i<10; i++) {
		723	/* Let other people run while the PLL stabilizes */
		724	vprintk(".");
491	giacomo	725	//current->state = TASK_INTERRUPTIBLE;
		726	//schedule_timeout(HZ/10);
428	giacomo	727
		728	if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
		729	btwrite(0,BT848_DSTATUS);
		730	} else {
170	giacomo	731	btwrite(0x08,BT848_TGCTRL);
		732	btv->pll.pll_current = btv->pll.pll_ofreq;
428	giacomo	733	vprintk(" ok\n");
		734	return;
170	giacomo	735	}
		736	}
428	giacomo	737	btv->pll.pll_current = -1;
		738	vprintk("failed\n");
		739	return;
170	giacomo	740	}
		741
428	giacomo	742	/* used to switch between the bt848's analog/digital video capture modes */
		743	void bt848A_set_timing(struct bttv *btv)
170	giacomo	744	{
428	giacomo	745	int i, len;
		746	int table_idx = bttv_tvnorms[btv->tvnorm].sram;
		747	int fsc = bttv_tvnorms[btv->tvnorm].Fsc;
		748
		749	if (UNSET == bttv_tvcards[btv->type].muxsel[btv->input]) {
		750	dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
		751	btv->nr,table_idx);
		752
		753	/* timing change...reset timing generator address */
		754	btwrite(0x00, BT848_TGCTRL);
		755	btwrite(0x02, BT848_TGCTRL);
		756	btwrite(0x00, BT848_TGCTRL);
		757
		758	len=SRAM_Table[table_idx][0];
		759	for(i = 1; i <= len; i++)
		760	btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
		761	btv->pll.pll_ofreq = 27000000;
		762
		763	set_pll(btv);
		764	btwrite(0x11, BT848_TGCTRL);
		765	btwrite(0x41, BT848_DVSIF);
		766	} else {
		767	btv->pll.pll_ofreq = fsc;
		768	set_pll(btv);
		769	btwrite(0x0, BT848_DVSIF);
		770	}
		771	}
		772
		773	/* ----------------------------------------------------------------------- */
		774
		775	static void bt848_bright(struct bttv *btv, int bright)
		776	{
		777	int value;
		778
		779	btv->bright = bright;
		780
		781	/* We want -128 to 127 we get 0-65535 */
		782	value = (bright >> 8) - 128;
		783	btwrite(value & 0xff, BT848_BRIGHT);
		784	}
		785
		786	static void bt848_hue(struct bttv *btv, int hue)
		787	{
		788	int value;
		789
		790	btv->hue = hue;
		791
		792	/* -128 to 127 */
		793	value = (hue >> 8) - 128;
		794	btwrite(value & 0xff, BT848_HUE);
		795	}
		796
		797	static void bt848_contrast(struct bttv *btv, int cont)
		798	{
		799	int value,hibit;
		800
		801	btv->contrast = cont;
		802
		803	/* 0-511 */
		804	value = (cont >> 7);
		805	hibit = (value >> 6) & 4;
		806	btwrite(value & 0xff, BT848_CONTRAST_LO);
		807	btaor(hibit, ~4, BT848_E_CONTROL);
		808	btaor(hibit, ~4, BT848_O_CONTROL);
		809	}
		810
		811	static void bt848_sat(struct bttv *btv, int color)
		812	{
		813	int val_u,val_v,hibits;
		814
		815	btv->saturation = color;
		816
		817	/* 0-511 for the color */
		818	val_u = color >> 7;
		819	val_v = ((color>>7)*180L)/254;
		820	hibits = (val_u >> 7) & 2;
		821	hibits \|= (val_v >> 8) & 1;
		822	btwrite(val_u & 0xff, BT848_SAT_U_LO);
		823	btwrite(val_v & 0xff, BT848_SAT_V_LO);
		824	btaor(hibits, ~3, BT848_E_CONTROL);
		825	btaor(hibits, ~3, BT848_O_CONTROL);
		826	}
		827
		828	/* ----------------------------------------------------------------------- */
		829
		830	static int
		831	video_mux(struct bttv *btv, unsigned int input)
		832	{
		833	int mux,mask2;
		834
		835	if (input >= bttv_tvcards[btv->type].video_inputs)
		836	return -EINVAL;
		837
170	giacomo	838	/* needed by RemoteVideo MX */
428	giacomo	839	mask2 = bttv_tvcards[btv->type].gpiomask2;
		840	if (mask2)
		841	btaor(mask2,~mask2,BT848_GPIO_OUT_EN);
170	giacomo	842
428	giacomo	843	if (input == btv->svhs) {
170	giacomo	844	btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
		845	btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
428	giacomo	846	} else {
170	giacomo	847	btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
		848	btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
		849	}
428	giacomo	850	mux = bttv_tvcards[btv->type].muxsel[input] & 3;
		851	btaor(mux<<5, ~(3<<5), BT848_IFORM);
		852	dprintk(KERN_DEBUG "bttv%d: video mux: input=%d mux=%d\n",
		853	btv->nr,input,mux);
170	giacomo	854
428	giacomo	855	/* card specific hook */
		856	if(bttv_tvcards[btv->type].muxsel_hook)
		857	bttv_tvcards[btv->type].muxsel_hook (btv, input);
		858	return 0;
		859	}
170	giacomo	860
428	giacomo	861	static char *audio_modes[] = {
		862	"audio: tuner", "audio: radio", "audio: extern",
		863	"audio: intern", "audio: off"
		864	};
170	giacomo	865
428	giacomo	866	static int
		867	audio_mux(struct bttv *btv, int mode)
		868	{
		869	int val,mux,i2c_mux,signal;
		870
		871	btaor(bttv_tvcards[btv->type].gpiomask,
		872	~bttv_tvcards[btv->type].gpiomask,BT848_GPIO_OUT_EN);
		873	signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
170	giacomo	874
428	giacomo	875	switch (mode) {
		876	case AUDIO_MUTE:
		877	btv->audio \|= AUDIO_MUTE;
		878	break;
		879	case AUDIO_UNMUTE:
		880	btv->audio &= ~AUDIO_MUTE;
		881	break;
		882	case AUDIO_TUNER:
		883	case AUDIO_RADIO:
		884	case AUDIO_EXTERN:
		885	case AUDIO_INTERN:
		886	btv->audio &= AUDIO_MUTE;
		887	btv->audio \|= mode;
		888	}
		889	i2c_mux = mux = (btv->audio & AUDIO_MUTE) ? AUDIO_OFF : btv->audio;
		890	if (btv->opt_automute && !signal && !btv->radio_user)
		891	mux = AUDIO_OFF;
		892	#if 0
		893	printk("bttv%d: amux: mode=%d audio=%d signal=%s mux=%d/%d irq=%s\n",
		894	btv->nr, mode, btv->audio, signal ? "yes" : "no",
		895	mux, i2c_mux, in_interrupt() ? "yes" : "no");
		896	#endif
		897
		898	val = bttv_tvcards[btv->type].audiomux[mux];
		899	btaor(val,~bttv_tvcards[btv->type].gpiomask, BT848_GPIO_DATA);
170	giacomo	900	if (bttv_gpio)
428	giacomo	901	bttv_gpio_tracking(btv,audio_modes[mux]);
		902	if (!in_interrupt())
		903	bttv_call_i2c_clients(btv,AUDC_SET_INPUT,&(i2c_mux));
		904	return 0;
		905	}
170	giacomo	906
428	giacomo	907	static void
		908	i2c_vidiocschan(struct bttv *btv)
		909	{
		910	struct video_channel c;
		911
		912	memset(&c,0,sizeof(c));
		913	c.norm = btv->tvnorm;
		914	c.channel = btv->input;
		915	bttv_call_i2c_clients(btv,VIDIOCSCHAN,&c);
		916	if (btv->type == BTTV_VOODOOTV_FM)
		917	bttv_tda9880_setnorm(btv,c.norm);
170	giacomo	918	}
		919
428	giacomo	920	static int
		921	set_tvnorm(struct bttv *btv, unsigned int norm)
170	giacomo	922	{
428	giacomo	923	const struct bttv_tvnorm *tvnorm;
170	giacomo	924
428	giacomo	925	if (norm < 0 \|\| norm >= BTTV_TVNORMS)
		926	return -EINVAL;
170	giacomo	927
428	giacomo	928	btv->tvnorm = norm;
		929	tvnorm = &bttv_tvnorms[norm];
		930
		931	btwrite(tvnorm->adelay, BT848_ADELAY);
		932	btwrite(tvnorm->bdelay, BT848_BDELAY);
		933	btaor(tvnorm->iform,~(BT848_IFORM_NORM\|BT848_IFORM_XTBOTH),
		934	BT848_IFORM);
		935	btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
		936	btwrite(1, BT848_VBI_PACK_DEL);
		937	bt848A_set_timing(btv);
		938
		939	switch (btv->type) {
		940	case BTTV_VOODOOTV_FM:
		941	bttv_tda9880_setnorm(btv,norm);
		942	break;
170	giacomo	943	#if 0
428	giacomo	944	case BTTV_OSPREY540:
		945	osprey_540_set_norm(btv,norm);
		946	break;
170	giacomo	947	#endif
428	giacomo	948	}
		949	return 0;
		950	}
170	giacomo	951
428	giacomo	952	static void
		953	set_input(struct bttv *btv, unsigned int input)
170	giacomo	954	{
428	giacomo	955	unsigned long flags;
		956
		957	btv->input = input;
		958	if (irq_iswitch) {
		959	spin_lock_irqsave(&btv->s_lock,flags);
		960	if (btv->curr.irqflags) {
		961	/* active capture -> delayed input switch */
		962	btv->new_input = input;
		963	} else {
		964	video_mux(btv,input);
		965	}
		966	spin_unlock_irqrestore(&btv->s_lock,flags);
		967	} else {
		968	video_mux(btv,input);
170	giacomo	969	}
428	giacomo	970	audio_mux(btv,(input == bttv_tvcards[btv->type].tuner ?
		971	AUDIO_TUNER : AUDIO_EXTERN));
		972	set_tvnorm(btv,btv->tvnorm);
		973	}
170	giacomo	974
428	giacomo	975	static void init_bt848(struct bttv *btv)
		976	{
		977	int val;
		978
		979	btwrite(0, BT848_SRESET);
		980	btwrite(0x00, BT848_CAP_CTL);
		981	btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
		982	btwrite(BT848_IFORM_XTAUTO \| BT848_IFORM_AUTO, BT848_IFORM);
		983
		984	/* set planar and packed mode trigger points and */
		985	/* set rising edge of inverted GPINTR pin as irq trigger */
		986	btwrite(BT848_GPIO_DMA_CTL_PKTP_32\|
		987	BT848_GPIO_DMA_CTL_PLTP1_16\|
		988	BT848_GPIO_DMA_CTL_PLTP23_16\|
		989	BT848_GPIO_DMA_CTL_GPINTC\|
		990	BT848_GPIO_DMA_CTL_GPINTI,
		991	BT848_GPIO_DMA_CTL);
		992
		993	val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
		994	btwrite(val, BT848_E_SCLOOP);
		995	btwrite(val, BT848_O_SCLOOP);
		996
		997	btwrite(0x20, BT848_E_VSCALE_HI);
		998	btwrite(0x20, BT848_O_VSCALE_HI);
		999	btwrite(BT848_ADC_RESERVED \| (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
		1000	BT848_ADC);
		1001
		1002	if (btv->opt_lumafilter) {
		1003	btwrite(0, BT848_E_CONTROL);
		1004	btwrite(0, BT848_O_CONTROL);
		1005	} else {
		1006	btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
		1007	btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
170	giacomo	1008	}
541	giacomo	1009
428	giacomo	1010	btwrite(0xfffffUL, BT848_INT_STAT);
		1011	btwrite((btv->triton1) \|
		1012	BT848_INT_GPINT \|
		1013	BT848_INT_SCERR \|
		1014	(fdsr ? BT848_INT_FDSR : 0) \|
		1015	BT848_INT_RISCI\|BT848_INT_OCERR\|BT848_INT_VPRES\|
		1016	BT848_INT_FMTCHG\|BT848_INT_HLOCK,
		1017	BT848_INT_MASK);
537	giacomo	1018
541	giacomo	1019
170	giacomo	1020	}
		1021
428	giacomo	1022	extern void bttv_reinit_bt848(struct bttv *btv)
		1023	{
		1024	unsigned long flags;
170	giacomo	1025
428	giacomo	1026	if (bttv_verbose)
		1027	printk(KERN_INFO "bttv%d: reset, reinitialize\n",btv->nr);
		1028	spin_lock_irqsave(&btv->s_lock,flags);
		1029	btv->errors=0;
		1030	bttv_set_dma(btv,0,0);
		1031	spin_unlock_irqrestore(&btv->s_lock,flags);
170	giacomo	1032
428	giacomo	1033	init_bt848(btv);
		1034	btv->pll.pll_current = -1;
		1035	set_input(btv,btv->input);
		1036	}
		1037
		1038	static int get_control(struct bttv btv, struct v4l2_control c)
170	giacomo	1039	{
428	giacomo	1040	struct video_audio va;
		1041	int i;
		1042
		1043	for (i = 0; i < BTTV_CTLS; i++)
		1044	if (bttv_ctls[i].id == c->id)
		1045	break;
		1046	if (i == BTTV_CTLS)
		1047	return -EINVAL;
		1048	if (i >= 4 && i <= 8) {
		1049	memset(&va,0,sizeof(va));
		1050	bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
		1051	if (btv->audio_hook)
		1052	btv->audio_hook(btv,&va,0);
		1053	}
		1054	switch (c->id) {
		1055	case V4L2_CID_BRIGHTNESS:
		1056	c->value = btv->bright;
		1057	break;
		1058	case V4L2_CID_HUE:
		1059	c->value = btv->hue;
		1060	break;
		1061	case V4L2_CID_CONTRAST:
		1062	c->value = btv->contrast;
		1063	break;
		1064	case V4L2_CID_SATURATION:
		1065	c->value = btv->saturation;
		1066	break;
170	giacomo	1067
428	giacomo	1068	case V4L2_CID_AUDIO_MUTE:
		1069	c->value = (VIDEO_AUDIO_MUTE & va.flags) ? 1 : 0;
		1070	break;
		1071	case V4L2_CID_AUDIO_VOLUME:
		1072	c->value = va.volume;
		1073	break;
		1074	case V4L2_CID_AUDIO_BALANCE:
		1075	c->value = va.balance;
		1076	break;
		1077	case V4L2_CID_AUDIO_BASS:
		1078	c->value = va.bass;
		1079	break;
		1080	case V4L2_CID_AUDIO_TREBLE:
		1081	c->value = va.treble;
		1082	break;
170	giacomo	1083
428	giacomo	1084	case V4L2_CID_PRIVATE_CHROMA_AGC:
		1085	c->value = btv->opt_chroma_agc;
		1086	break;
		1087	case V4L2_CID_PRIVATE_COMBFILTER:
		1088	c->value = btv->opt_combfilter;
		1089	break;
		1090	case V4L2_CID_PRIVATE_LUMAFILTER:
		1091	c->value = btv->opt_lumafilter;
		1092	break;
		1093	case V4L2_CID_PRIVATE_AUTOMUTE:
		1094	c->value = btv->opt_automute;
		1095	break;
		1096	case V4L2_CID_PRIVATE_AGC_CRUSH:
		1097	c->value = btv->opt_adc_crush;
		1098	break;
		1099	case V4L2_CID_PRIVATE_VCR_HACK:
		1100	c->value = btv->opt_vcr_hack;
		1101	break;
		1102	default:
		1103	return -EINVAL;
170	giacomo	1104	}
		1105	return 0;
		1106	}
		1107
428	giacomo	1108	static int set_control(struct bttv btv, struct v4l2_control c)
170	giacomo	1109	{
428	giacomo	1110	struct video_audio va;
		1111	int i,val;
170	giacomo	1112
428	giacomo	1113	for (i = 0; i < BTTV_CTLS; i++)
		1114	if (bttv_ctls[i].id == c->id)
		1115	break;
		1116	if (i == BTTV_CTLS)
		1117	return -EINVAL;
		1118	if (i >= 4 && i <= 8) {
		1119	memset(&va,0,sizeof(va));
		1120	bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
		1121	if (btv->audio_hook)
		1122	btv->audio_hook(btv,&va,0);
170	giacomo	1123	}
428	giacomo	1124	switch (c->id) {
		1125	case V4L2_CID_BRIGHTNESS:
		1126	bt848_bright(btv,c->value);
		1127	break;
		1128	case V4L2_CID_HUE:
		1129	bt848_hue(btv,c->value);
		1130	break;
		1131	case V4L2_CID_CONTRAST:
		1132	bt848_contrast(btv,c->value);
		1133	break;
		1134	case V4L2_CID_SATURATION:
		1135	bt848_sat(btv,c->value);
		1136	break;
		1137	case V4L2_CID_AUDIO_MUTE:
		1138	if (c->value) {
		1139	va.flags \|= VIDEO_AUDIO_MUTE;
		1140	audio_mux(btv, AUDIO_MUTE);
		1141	} else {
		1142	va.flags &= ~VIDEO_AUDIO_MUTE;
		1143	audio_mux(btv, AUDIO_UNMUTE);
170	giacomo	1144	}
428	giacomo	1145	break;
170	giacomo	1146
428	giacomo	1147	case V4L2_CID_AUDIO_VOLUME:
		1148	va.volume = c->value;
		1149	break;
		1150	case V4L2_CID_AUDIO_BALANCE:
		1151	va.balance = c->value;
		1152	break;
		1153	case V4L2_CID_AUDIO_BASS:
		1154	va.bass = c->value;
		1155	break;
		1156	case V4L2_CID_AUDIO_TREBLE:
		1157	va.treble = c->value;
		1158	break;
170	giacomo	1159
428	giacomo	1160	case V4L2_CID_PRIVATE_CHROMA_AGC:
		1161	btv->opt_chroma_agc = c->value;
		1162	val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
		1163	btwrite(val, BT848_E_SCLOOP);
		1164	btwrite(val, BT848_O_SCLOOP);
		1165	break;
		1166	case V4L2_CID_PRIVATE_COMBFILTER:
		1167	btv->opt_combfilter = c->value;
		1168	break;
		1169	case V4L2_CID_PRIVATE_LUMAFILTER:
		1170	btv->opt_lumafilter = c->value;
		1171	if (btv->opt_lumafilter) {
		1172	btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
		1173	btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
		1174	} else {
		1175	btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
		1176	btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
170	giacomo	1177	}
428	giacomo	1178	break;
		1179	case V4L2_CID_PRIVATE_AUTOMUTE:
		1180	btv->opt_automute = c->value;
		1181	break;
		1182	case V4L2_CID_PRIVATE_AGC_CRUSH:
		1183	btv->opt_adc_crush = c->value;
		1184	btwrite(BT848_ADC_RESERVED \| (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
		1185	BT848_ADC);
		1186	break;
		1187	case V4L2_CID_PRIVATE_VCR_HACK:
		1188	btv->opt_vcr_hack = c->value;
		1189	break;
		1190	default:
		1191	return -EINVAL;
170	giacomo	1192	}
428	giacomo	1193	if (i >= 4 && i <= 8) {
		1194	bttv_call_i2c_clients(btv, VIDIOCSAUDIO, &va);
		1195	if (btv->audio_hook)
		1196	btv->audio_hook(btv,&va,1);
		1197	}
170	giacomo	1198	return 0;
		1199	}
428	giacomo	1200
		1201	/* ----------------------------------------------------------------------- */
		1202
		1203	void bttv_gpio_tracking(struct bttv btv, char comment)
170	giacomo	1204	{
428	giacomo	1205	unsigned int outbits, data;
		1206	outbits = btread(BT848_GPIO_OUT_EN);
		1207	data = btread(BT848_GPIO_DATA);
		1208	printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
		1209	btv->nr,outbits,data & outbits, data & ~outbits, comment);
		1210	}
170	giacomo	1211
428	giacomo	1212	void bttv_field_count(struct bttv *btv)
		1213	{
		1214	int need_count = 0;
170	giacomo	1215
428	giacomo	1216	if (btv->users)
		1217	need_count++;
170	giacomo	1218
428	giacomo	1219	if (need_count) {
		1220	/* start field counter */
		1221	btor(BT848_INT_VSYNC,BT848_INT_MASK);
		1222	} else {
		1223	/* stop field counter */
		1224	btand(~BT848_INT_VSYNC,BT848_INT_MASK);
		1225	btv->field_count = 0;
170	giacomo	1226	}
		1227	}
		1228
428	giacomo	1229	static const struct bttv_format*
		1230	format_by_palette(int palette)
170	giacomo	1231	{
428	giacomo	1232	unsigned int i;
170	giacomo	1233
428	giacomo	1234	for (i = 0; i < BTTV_FORMATS; i++) {
		1235	if (-1 == bttv_formats[i].palette)
		1236	continue;
		1237	if (bttv_formats[i].palette == palette)
		1238	return bttv_formats+i;
		1239	}
		1240	return NULL;
		1241	}
170	giacomo	1242
428	giacomo	1243	static const struct bttv_format*
		1244	format_by_fourcc(int fourcc)
		1245	{
		1246	unsigned int i;
170	giacomo	1247
428	giacomo	1248	for (i = 0; i < BTTV_FORMATS; i++) {
		1249	if (-1 == bttv_formats[i].fourcc)
		1250	continue;
		1251	if (bttv_formats[i].fourcc == fourcc)
		1252	return bttv_formats+i;
		1253	}
		1254	return NULL;
170	giacomo	1255	}
		1256
428	giacomo	1257	/* ----------------------------------------------------------------------- */
		1258	/* misc helpers */
		1259
		1260	static int
		1261	bttv_switch_overlay(struct bttv btv, struct bttv_fh fh,
		1262	struct bttv_buffer *new)
170	giacomo	1263	{
428	giacomo	1264	struct bttv_buffer *old;
		1265	unsigned long flags;
		1266	int retval = 0;
170	giacomo	1267
607	giacomo	1268	dprintk("switch_overlay: enter [new=%x]\n",(int)new);
428	giacomo	1269	if (new)
		1270	new->vb.state = STATE_DONE;
		1271	spin_lock_irqsave(&btv->s_lock,flags);
		1272	old = btv->screen;
		1273	btv->screen = new;
		1274	bttv_set_dma(btv, 0x03, 1);
		1275	spin_unlock_irqrestore(&btv->s_lock,flags);
		1276	if (NULL == new)
		1277	free_btres(btv,fh,RESOURCE_OVERLAY);
		1278	if (NULL != old) {
607	giacomo	1279	dprintk("switch_overlay: old=%x state is %d\n",(int)old,old->vb.state);
608	giacomo	1280	bttv_dma_free(btv, old);
428	giacomo	1281	kfree(old);
		1282	}
		1283	dprintk("switch_overlay: done\n");
		1284	return retval;
		1285	}
170	giacomo	1286
428	giacomo	1287	/* ----------------------------------------------------------------------- */
		1288	/* video4linux (1) interface */
170	giacomo	1289
428	giacomo	1290	static int bttv_prepare_buffer(struct bttv btv, struct bttv_buffer buf,
		1291	const struct bttv_format *fmt,
		1292	unsigned int width, unsigned int height,
		1293	enum v4l2_field field)
		1294	{
		1295	int redo_dma_risc = 0;
		1296	int rc;
		1297
		1298	/* check settings */
		1299	if (NULL == fmt)
		1300	return -EINVAL;
		1301	if (fmt->btformat == BT848_COLOR_FMT_RAW) {
		1302	width = RAW_BPL;
		1303	height = RAW_LINES*2;
		1304	if (width*height > buf->vb.bsize)
		1305	return -EINVAL;
		1306	buf->vb.size = buf->vb.bsize;
		1307	} else {
		1308	if (width < 48 \|\|
		1309	height < 32 \|\|
		1310	width > bttv_tvnorms[btv->tvnorm].swidth \|\|
		1311	height > bttv_tvnorms[btv->tvnorm].sheight)
		1312	return -EINVAL;
		1313	buf->vb.size = (width * height * fmt->depth) >> 3;
		1314	if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
		1315	return -EINVAL;
170	giacomo	1316	}
		1317
428	giacomo	1318	/* alloc + fill struct bttv_buffer (if changed) */
		1319	if (buf->vb.width != width \|\| buf->vb.height != height \|\|
		1320	buf->vb.field != field \|\|
		1321	buf->tvnorm != btv->tvnorm \|\| buf->fmt != fmt) {
		1322	buf->vb.width = width;
		1323	buf->vb.height = height;
		1324	buf->vb.field = field;
		1325	buf->tvnorm = btv->tvnorm;
		1326	buf->fmt = fmt;
		1327	redo_dma_risc = 1;
170	giacomo	1328	}
		1329
428	giacomo	1330	/* alloc risc memory */
		1331	if (STATE_NEEDS_INIT == buf->vb.state) {
		1332	redo_dma_risc = 1;
		1333	if (0 != (rc = videobuf_iolock(btv->dev,&buf->vb,&btv->fbuf)))
		1334	goto fail;
		1335	}
170	giacomo	1336
428	giacomo	1337	if (redo_dma_risc)
		1338	if (0 != (rc = bttv_buffer_risc(btv,buf)))
		1339	goto fail;
		1340
		1341	buf->vb.state = STATE_PREPARED;
		1342	return 0;
		1343
		1344	fail:
		1345	bttv_dma_free(btv,buf);
		1346	return rc;
170	giacomo	1347	}
		1348
428	giacomo	1349	static int
		1350	buffer_setup(struct file file, unsigned int count, unsigned int *size)
170	giacomo	1351	{
428	giacomo	1352	struct bttv_fh *fh = file->private_data;
		1353
		1354	size = fh->fmt->depthfh->width*fh->height >> 3;
		1355	if (0 == *count)
		1356	*count = gbuffers;
		1357	while (size count > gbuffers gbufsize)
		1358	(*count)--;
		1359	return 0;
		1360	}
170	giacomo	1361
428	giacomo	1362	static int
		1363	buffer_prepare(struct file file, struct videobuf_buffer vb,
		1364	enum v4l2_field field)
		1365	{
		1366	struct bttv_buffer buf = (struct bttv_buffer)vb;
		1367	struct bttv_fh *fh = file->private_data;
170	giacomo	1368
428	giacomo	1369	return bttv_prepare_buffer(fh->btv, buf, fh->fmt,
		1370	fh->width, fh->height, field);
170	giacomo	1371	}
		1372
428	giacomo	1373	static void
		1374	buffer_queue(struct file file, struct videobuf_buffer vb)
170	giacomo	1375	{
428	giacomo	1376	struct bttv_buffer buf = (struct bttv_buffer)vb;
		1377	struct bttv_fh *fh = file->private_data;
170	giacomo	1378
428	giacomo	1379	buf->vb.state = STATE_QUEUED;
		1380	list_add_tail(&buf->vb.queue,&fh->btv->capture);
		1381	bttv_set_dma(fh->btv, 0x03, 1);
		1382	}
170	giacomo	1383
428	giacomo	1384	static void buffer_release(struct file file, struct videobuf_buffer vb)
		1385	{
		1386	struct bttv_buffer buf = (struct bttv_buffer)vb;
		1387	struct bttv_fh *fh = file->private_data;
170	giacomo	1388
428	giacomo	1389	bttv_dma_free(fh->btv,buf);
170	giacomo	1390	}
		1391
428	giacomo	1392	static struct videobuf_queue_ops bttv_video_qops = {
		1393	.buf_setup = buffer_setup,
		1394	.buf_prepare = buffer_prepare,
		1395	.buf_queue = buffer_queue,
		1396	.buf_release = buffer_release,
170	giacomo	1397	};
		1398
516	giacomo	1399	/*
428	giacomo	1400	static const char *v4l1_ioctls[] = {
		1401	"?", "CGAP", "GCHAN", "SCHAN", "GTUNER", "STUNER", "GPICT", "SPICT",
		1402	"CCAPTURE", "GWIN", "SWIN", "GFBUF", "SFBUF", "KEY", "GFREQ",
		1403	"SFREQ", "GAUDIO", "SAUDIO", "SYNC", "MCAPTURE", "GMBUF", "GUNIT",
		1404	"GCAPTURE", "SCAPTURE", "SPLAYMODE", "SWRITEMODE", "GPLAYINFO",
		1405	"SMICROCODE", "GVBIFMT", "SVBIFMT" };
516	giacomo	1406	*/
428	giacomo	1407	#define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
		1408
		1409	int bttv_common_ioctls(struct bttv btv, unsigned int cmd, void arg)
170	giacomo	1410	{
428	giacomo	1411	switch (cmd) {
		1412	case BTTV_VERSION:
		1413	return BTTV_VERSION_CODE;
170	giacomo	1414
428	giacomo	1415	/* * v4l1 * ************************************************ */
		1416	case VIDIOCGFREQ:
		1417	{
		1418	unsigned long *freq = arg;
		1419	*freq = btv->freq;
		1420	return 0;
170	giacomo	1421	}
428	giacomo	1422	case VIDIOCSFREQ:
		1423	{
		1424	unsigned long *freq = arg;
480	giacomo	1425	//down(&btv->lock);
428	giacomo	1426	btv->freq=*freq;
		1427	bttv_call_i2c_clients(btv,VIDIOCSFREQ,freq);
		1428	if (btv->has_matchbox && btv->radio_user)
		1429	tea5757_set_freq(btv,*freq);
480	giacomo	1430	//up(&btv->lock);
428	giacomo	1431	return 0;
170	giacomo	1432	}
		1433
428	giacomo	1434	case VIDIOCGTUNER:
		1435	{
		1436	struct video_tuner *v = arg;
		1437
		1438	if (UNSET == bttv_tvcards[btv->type].tuner)
		1439	return -EINVAL;
		1440	if (v->tuner) /* Only tuner 0 */
		1441	return -EINVAL;
		1442	strcpy(v->name, "Television");
		1443	v->rangelow = 0;
		1444	v->rangehigh = 0x7FFFFFFF;
		1445	v->flags = VIDEO_TUNER_PAL\|VIDEO_TUNER_NTSC\|VIDEO_TUNER_SECAM;
		1446	v->mode = btv->tvnorm;
		1447	v->signal = (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC) ? 0xFFFF : 0;
		1448	bttv_call_i2c_clients(btv,cmd,v);
		1449	return 0;
		1450	}
		1451	case VIDIOCSTUNER:
		1452	{
		1453	struct video_tuner *v = arg;
170	giacomo	1454
428	giacomo	1455	if (v->tuner) /* Only tuner 0 */
		1456	return -EINVAL;
		1457	if (v->mode >= BTTV_TVNORMS)
		1458	return -EINVAL;
170	giacomo	1459
480	giacomo	1460	//down(&btv->lock);
428	giacomo	1461	set_tvnorm(btv,v->mode);
		1462	bttv_call_i2c_clients(btv,cmd,v);
480	giacomo	1463	//up(&btv->lock);
428	giacomo	1464	return 0;
		1465	}
		1466
		1467	case VIDIOCGCHAN:
		1468	{
		1469	struct video_channel *v = arg;
		1470	unsigned int channel = v->channel;
170	giacomo	1471
428	giacomo	1472	if (channel >= bttv_tvcards[btv->type].video_inputs)
		1473	return -EINVAL;
		1474	v->tuners=0;
		1475	v->flags = VIDEO_VC_AUDIO;
		1476	v->type = VIDEO_TYPE_CAMERA;
		1477	v->norm = btv->tvnorm;
		1478	if (channel == bttv_tvcards[btv->type].tuner) {
		1479	strcpy(v->name,"Television");
		1480	v->flags\|=VIDEO_VC_TUNER;
		1481	v->type=VIDEO_TYPE_TV;
		1482	v->tuners=1;
		1483	} else if (channel == btv->svhs) {
		1484	strcpy(v->name,"S-Video");
		1485	} else {
463	giacomo	1486	sprintf26(v->name,"Composite%d",channel);
428	giacomo	1487	}
		1488	return 0;
		1489	}
		1490	case VIDIOCSCHAN:
		1491	{
		1492	struct video_channel *v = arg;
		1493	unsigned int channel = v->channel;
170	giacomo	1494
428	giacomo	1495	if (channel >= bttv_tvcards[btv->type].video_inputs)
		1496	return -EINVAL;
		1497	if (v->norm >= BTTV_TVNORMS)
		1498	return -EINVAL;
480	giacomo	1499	//down(&btv->lock);
428	giacomo	1500	if (channel == btv->input &&
		1501	v->norm == btv->tvnorm) {
		1502	/* nothing to do */
480	giacomo	1503	//up(&btv->lock);
428	giacomo	1504	return 0;
		1505	}
170	giacomo	1506
428	giacomo	1507	btv->tvnorm = v->norm;
		1508	set_input(btv,v->channel);
480	giacomo	1509	//up(&btv->lock);
428	giacomo	1510	return 0;
		1511	}
170	giacomo	1512
428	giacomo	1513	case VIDIOCGAUDIO:
		1514	{
		1515	struct video_audio *v = arg;
170	giacomo	1516
428	giacomo	1517	memset(v,0,sizeof(*v));
		1518	strcpy(v->name,"Television");
		1519	v->flags \|= VIDEO_AUDIO_MUTABLE;
		1520	v->mode = VIDEO_SOUND_MONO;
170	giacomo	1521
480	giacomo	1522	//down(&btv->lock);
428	giacomo	1523	bttv_call_i2c_clients(btv,cmd,v);
170	giacomo	1524
428	giacomo	1525	/* card specific hooks */
		1526	if (btv->audio_hook)
		1527	btv->audio_hook(btv,v,0);
170	giacomo	1528
480	giacomo	1529	//up(&btv->lock);
428	giacomo	1530	return 0;
		1531	}
		1532	case VIDIOCSAUDIO:
		1533	{
		1534	struct video_audio *v = arg;
		1535	unsigned int audio = v->audio;
170	giacomo	1536
428	giacomo	1537	if (audio >= bttv_tvcards[btv->type].audio_inputs)
		1538	return -EINVAL;
170	giacomo	1539
480	giacomo	1540	//down(&btv->lock);
428	giacomo	1541	audio_mux(btv, (v->flags&VIDEO_AUDIO_MUTE) ? AUDIO_MUTE : AUDIO_UNMUTE);
		1542	bttv_call_i2c_clients(btv,cmd,v);
170	giacomo	1543
428	giacomo	1544	/* card specific hooks */
		1545	if (btv->audio_hook)
		1546	btv->audio_hook(btv,v,1);
		1547
480	giacomo	1548	//up(&btv->lock);
428	giacomo	1549	return 0;
		1550	}
170	giacomo	1551
428	giacomo	1552	/* * v4l2 * ************************************************ */
		1553	case VIDIOC_ENUMSTD:
		1554	{
		1555	struct v4l2_standard *e = arg;
		1556	unsigned int index = e->index;
		1557
		1558	if (index >= BTTV_TVNORMS)
		1559	return -EINVAL;
516	giacomo	1560	//v4l2_video_std_construct(e, bttv_tvnorms[e->index].v4l2_id,
		1561	// bttv_tvnorms[e->index].name);
428	giacomo	1562	e->index = index;
		1563	return 0;
		1564	}
		1565	case VIDIOC_G_STD:
		1566	{
		1567	v4l2_std_id *id = arg;
		1568	*id = bttv_tvnorms[btv->tvnorm].v4l2_id;
		1569	return 0;
		1570	}
		1571	case VIDIOC_S_STD:
		1572	{
		1573	v4l2_std_id *id = arg;
		1574	unsigned int i;
170	giacomo	1575
428	giacomo	1576	for (i = 0; i < BTTV_TVNORMS; i++)
		1577	if (*id & bttv_tvnorms[i].v4l2_id)
		1578	break;
		1579	if (i == BTTV_TVNORMS)
		1580	return -EINVAL;
170	giacomo	1581
480	giacomo	1582	//down(&btv->lock);
428	giacomo	1583	set_tvnorm(btv,i);
		1584	i2c_vidiocschan(btv);
480	giacomo	1585	//up(&btv->lock);
428	giacomo	1586	return 0;
		1587	}
		1588	case VIDIOC_QUERYSTD:
		1589	{
		1590	v4l2_std_id *id = arg;
		1591
		1592	if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
		1593	*id = V4L2_STD_625_50;
		1594	else
		1595	*id = V4L2_STD_525_60;
		1596	return 0;
		1597	}
170	giacomo	1598
428	giacomo	1599	case VIDIOC_ENUMINPUT:
		1600	{
		1601	struct v4l2_input *i = arg;
		1602	unsigned int n;
		1603
		1604	n = i->index;
		1605	if (n >= bttv_tvcards[btv->type].video_inputs)
		1606	return -EINVAL;
		1607	memset(i,0,sizeof(*i));
		1608	i->index = n;
		1609	i->type = V4L2_INPUT_TYPE_CAMERA;
		1610	i->audioset = 1;
		1611	if (i->index == bttv_tvcards[btv->type].tuner) {
463	giacomo	1612	sprintf26(i->name, "Television");
428	giacomo	1613	i->type = V4L2_INPUT_TYPE_TUNER;
		1614	i->tuner = 0;
		1615	} else if (i->index == btv->svhs) {
463	giacomo	1616	sprintf26(i->name, "S-Video");
428	giacomo	1617	} else {
463	giacomo	1618	sprintf26(i->name,"Composite%d",i->index);
428	giacomo	1619	}
		1620	if (i->index == btv->input) {
		1621	__u32 dstatus = btread(BT848_DSTATUS);
		1622	if (0 == (dstatus & BT848_DSTATUS_PRES))
		1623	i->status \|= V4L2_IN_ST_NO_SIGNAL;
		1624	if (0 == (dstatus & BT848_DSTATUS_HLOC))
		1625	i->status \|= V4L2_IN_ST_NO_H_LOCK;
		1626	}
		1627	for (n = 0; n < BTTV_TVNORMS; n++)
		1628	i->std \|= bttv_tvnorms[n].v4l2_id;
		1629	return 0;
		1630	}
		1631	case VIDIOC_G_INPUT:
		1632	{
		1633	int *i = arg;
		1634	*i = btv->input;
		1635	return 0;
		1636	}
		1637	case VIDIOC_S_INPUT:
		1638	{
		1639	unsigned int *i = arg;
		1640
		1641	if (*i > bttv_tvcards[btv->type].video_inputs)
		1642	return -EINVAL;
480	giacomo	1643	//down(&btv->lock);
428	giacomo	1644	set_input(btv,*i);
		1645	i2c_vidiocschan(btv);
480	giacomo	1646	//up(&btv->lock);
428	giacomo	1647	return 0;
		1648	}
		1649
		1650	case VIDIOC_G_TUNER:
		1651	{
		1652	struct v4l2_tuner *t = arg;
170	giacomo	1653
428	giacomo	1654	if (UNSET == bttv_tvcards[btv->type].tuner)
		1655	return -EINVAL;
		1656	if (0 != t->index)
		1657	return -EINVAL;
480	giacomo	1658	//down(&btv->lock);
428	giacomo	1659	memset(t,0,sizeof(*t));
		1660	strcpy(t->name, "Television");
		1661	t->type = V4L2_TUNER_ANALOG_TV;
		1662	t->rangehigh = 0xffffffffUL;
		1663	t->capability = V4L2_TUNER_CAP_NORM;
		1664	t->rxsubchans = V4L2_TUNER_SUB_MONO;
		1665	if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
		1666	t->signal = 0xffff;
		1667	{
		1668	/* Hmmm ... */
		1669	struct video_audio va;
		1670	memset(&va, 0, sizeof(struct video_audio));
		1671	bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
		1672	if (btv->audio_hook)
		1673	btv->audio_hook(btv,&va,0);
		1674	if(va.mode & VIDEO_SOUND_STEREO) {
		1675	t->audmode = V4L2_TUNER_MODE_STEREO;
		1676	t->rxsubchans \|= V4L2_TUNER_SUB_STEREO;
		1677	}
		1678	if(va.mode & VIDEO_SOUND_LANG1) {
		1679	t->audmode = V4L2_TUNER_MODE_LANG1;
		1680	t->rxsubchans = V4L2_TUNER_SUB_LANG1
		1681	\| V4L2_TUNER_SUB_LANG2;
		1682	}
		1683	}
		1684	/* FIXME: fill capability+audmode */
480	giacomo	1685	//up(&btv->lock);
428	giacomo	1686	return 0;
		1687	}
		1688	case VIDIOC_S_TUNER:
		1689	{
		1690	struct v4l2_tuner *t = arg;
170	giacomo	1691
428	giacomo	1692	if (UNSET == bttv_tvcards[btv->type].tuner)
		1693	return -EINVAL;
		1694	if (0 != t->index)
		1695	return -EINVAL;
480	giacomo	1696	//down(&btv->lock);
428	giacomo	1697	{
		1698	struct video_audio va;
		1699	memset(&va, 0, sizeof(struct video_audio));
		1700	bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
		1701	if (t->audmode == V4L2_TUNER_MODE_MONO)
		1702	va.mode = VIDEO_SOUND_MONO;
		1703	else if (t->audmode == V4L2_TUNER_MODE_STEREO)
		1704	va.mode = VIDEO_SOUND_STEREO;
		1705	else if (t->audmode == V4L2_TUNER_MODE_LANG1)
		1706	va.mode = VIDEO_SOUND_LANG1;
		1707	else if (t->audmode == V4L2_TUNER_MODE_LANG2)
		1708	va.mode = VIDEO_SOUND_LANG2;
		1709	bttv_call_i2c_clients(btv, VIDIOCSAUDIO, &va);
		1710	if (btv->audio_hook)
		1711	btv->audio_hook(btv,&va,1);
		1712	}
480	giacomo	1713	//up(&btv->lock);
428	giacomo	1714	return 0;
		1715	}
		1716
		1717	case VIDIOC_G_FREQUENCY:
		1718	{
		1719	struct v4l2_frequency *f = arg;
		1720
		1721	memset(f,0,sizeof(*f));
		1722	f->type = V4L2_TUNER_ANALOG_TV;
		1723	f->frequency = btv->freq;
		1724	return 0;
		1725	}
		1726	case VIDIOC_S_FREQUENCY:
		1727	{
		1728	struct v4l2_frequency *f = arg;
		1729
		1730	if (unlikely(f->tuner != 0))
		1731	return -EINVAL;
		1732	if (unlikely(f->type != V4L2_TUNER_ANALOG_TV))
		1733	return -EINVAL;
480	giacomo	1734	//down(&btv->lock);
428	giacomo	1735	btv->freq = f->frequency;
		1736	bttv_call_i2c_clients(btv,VIDIOCSFREQ,&btv->freq);
		1737	if (btv->has_matchbox && btv->radio_user)
		1738	tea5757_set_freq(btv,btv->freq);
480	giacomo	1739	//up(&btv->lock);
428	giacomo	1740	return 0;
		1741	}
		1742
		1743	default:
		1744	return -ENOIOCTLCMD;
		1745
		1746	}
		1747	return 0;
170	giacomo	1748	}
		1749
428	giacomo	1750	static int verify_window(const struct bttv_tvnorm *tvn,
		1751	struct v4l2_window *win, int fixup)
170	giacomo	1752	{
428	giacomo	1753	enum v4l2_field field;
		1754	int maxw, maxh;
170	giacomo	1755
428	giacomo	1756	if (win->w.width < 48 \|\| win->w.height < 32)
		1757	return -EINVAL;
		1758	if (win->clipcount > 2048)
		1759	return -EINVAL;
170	giacomo	1760
428	giacomo	1761	field = win->field;
		1762	maxw = tvn->swidth;
		1763	maxh = tvn->sheight;
170	giacomo	1764
428	giacomo	1765	if (V4L2_FIELD_ANY == field) {
		1766	field = (win->w.height > maxh/2)
		1767	? V4L2_FIELD_INTERLACED
		1768	: V4L2_FIELD_TOP;
		1769	}
		1770	switch (field) {
		1771	case V4L2_FIELD_TOP:
		1772	case V4L2_FIELD_BOTTOM:
		1773	maxh = maxh / 2;
		1774	break;
		1775	case V4L2_FIELD_INTERLACED:
		1776	break;
		1777	default:
		1778	return -EINVAL;
		1779	}
170	giacomo	1780
428	giacomo	1781	if (!fixup && (win->w.width > maxw \|\| win->w.height > maxh))
		1782	return -EINVAL;
170	giacomo	1783
428	giacomo	1784	if (win->w.width > maxw)
		1785	win->w.width = maxw;
		1786	if (win->w.height > maxh)
		1787	win->w.height = maxh;
		1788	win->field = field;
		1789	return 0;
170	giacomo	1790	}
		1791
428	giacomo	1792	static int setup_window(struct bttv_fh fh, struct bttv btv,
		1793	struct v4l2_window *win, int fixup)
170	giacomo	1794	{
428	giacomo	1795	struct v4l2_clip *clips = NULL;
		1796	int n,size,retval = 0;
170	giacomo	1797
428	giacomo	1798	if (NULL == fh->ovfmt)
		1799	return -EINVAL;
		1800	retval = verify_window(&bttv_tvnorms[btv->tvnorm],win,fixup);
		1801	if (0 != retval)
		1802	return retval;
257	giacomo	1803
428	giacomo	1804	/* copy clips -- luckily v4l1 + v4l2 are binary
		1805	compatible here ...*/
		1806	n = win->clipcount;
		1807	size = sizeof(clips)(n+4);
		1808	clips = kmalloc(size,GFP_KERNEL);
		1809	if (NULL == clips)
		1810	return -ENOMEM;
		1811	if (n > 0) {
		1812	if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
		1813	kfree(clips);
		1814	return -EFAULT;
		1815	}
		1816	}
541	giacomo	1817
428	giacomo	1818	/* clip against screen */
		1819	if (NULL != btv->fbuf.base)
		1820	n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
		1821	&win->w, clips, n);
		1822	btcx_sort_clips(clips,n);
		1823
		1824	/* 4-byte alignments */
		1825	switch (fh->ovfmt->depth) {
		1826	case 8:
		1827	case 24:
		1828	btcx_align(&win->w, clips, n, 3);
		1829	break;
		1830	case 16:
		1831	btcx_align(&win->w, clips, n, 1);
		1832	break;
		1833	case 32:
		1834	/* no alignment fixups needed */
		1835	break;
		1836	default:
		1837	BUG();
		1838	}
179	giacomo	1839
480	giacomo	1840	//down(&fh->cap.lock);
428	giacomo	1841	if (fh->ov.clips)
		1842	kfree(fh->ov.clips);
		1843	fh->ov.clips = clips;
		1844	fh->ov.nclips = n;
		1845
		1846	fh->ov.w = win->w;
		1847	fh->ov.field = win->field;
		1848	fh->ov.setup_ok = 1;
		1849	btv->init.ov.w.width = win->w.width;
		1850	btv->init.ov.w.height = win->w.height;
		1851	btv->init.ov.field = win->field;
		1852
		1853	/* update overlay if needed */
		1854	retval = 0;
		1855	if (check_btres(fh, RESOURCE_OVERLAY)) {
		1856	struct bttv_buffer *new;
		1857
		1858	new = videobuf_alloc(sizeof(*new));
		1859	bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
		1860	retval = bttv_switch_overlay(btv,fh,new);
		1861	}
541	giacomo	1862
480	giacomo	1863	//up(&fh->cap.lock);
428	giacomo	1864	return retval;
170	giacomo	1865	}
		1866
428	giacomo	1867	/* ----------------------------------------------------------------------- */
170	giacomo	1868
428	giacomo	1869	static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
170	giacomo	1870	{
428	giacomo	1871	struct videobuf_queue* q = NULL;
		1872
		1873	switch (fh->type) {
		1874	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
		1875	q = &fh->cap;
		1876	break;
		1877	case V4L2_BUF_TYPE_VBI_CAPTURE:
		1878	q = &fh->vbi;
		1879	break;
		1880	default:
		1881	BUG();
		1882	}
		1883	return q;
170	giacomo	1884	}
		1885
428	giacomo	1886	static int bttv_resource(struct bttv_fh *fh)
170	giacomo	1887	{
428	giacomo	1888	int res = 0;
		1889
		1890	switch (fh->type) {
		1891	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
		1892	res = RESOURCE_VIDEO;
		1893	break;
		1894	case V4L2_BUF_TYPE_VBI_CAPTURE:
		1895	res = RESOURCE_VBI;
		1896	break;
		1897	default:
		1898	BUG();
		1899	}
		1900	return res;
170	giacomo	1901	}
		1902
428	giacomo	1903	static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
170	giacomo	1904	{
428	giacomo	1905	struct videobuf_queue *q = bttv_queue(fh);
		1906	int res = bttv_resource(fh);
170	giacomo	1907
428	giacomo	1908	if (check_btres(fh,res))
		1909	return -EBUSY;
		1910	if (videobuf_queue_is_busy(q))
		1911	return -EBUSY;
		1912	fh->type = type;
		1913	return 0;
170	giacomo	1914	}
		1915
428	giacomo	1916	static int bttv_g_fmt(struct bttv_fh fh, struct v4l2_format f)
170	giacomo	1917	{
428	giacomo	1918	switch (f->type) {
		1919	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
		1920	memset(&f->fmt.pix,0,sizeof(struct v4l2_pix_format));
		1921	f->fmt.pix.width = fh->width;
		1922	f->fmt.pix.height = fh->height;
		1923	f->fmt.pix.field = fh->cap.field;
		1924	f->fmt.pix.pixelformat = fh->fmt->fourcc;
		1925	f->fmt.pix.bytesperline =
		1926	(f->fmt.pix.width * fh->fmt->depth) >> 3;
		1927	f->fmt.pix.sizeimage =
		1928	f->fmt.pix.height * f->fmt.pix.bytesperline;
		1929	return 0;
		1930	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
		1931	memset(&f->fmt.win,0,sizeof(struct v4l2_window));
		1932	f->fmt.win.w = fh->ov.w;
		1933	f->fmt.win.field = fh->ov.field;
		1934	return 0;
		1935	case V4L2_BUF_TYPE_VBI_CAPTURE:
516	giacomo	1936	//bttv_vbi_get_fmt(fh,f);
428	giacomo	1937	return 0;
		1938	default:
		1939	return -EINVAL;
		1940	}
		1941	}
170	giacomo	1942
428	giacomo	1943	static int bttv_try_fmt(struct bttv_fh fh, struct bttv btv,
		1944	struct v4l2_format *f)
		1945	{
		1946	switch (f->type) {
		1947	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
		1948	{
		1949	const struct bttv_format *fmt;
		1950	enum v4l2_field field;
		1951	unsigned int maxw,maxh;
		1952
		1953	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
		1954	if (NULL == fmt)
		1955	return -EINVAL;
		1956
		1957	/* fixup format */
		1958	maxw = bttv_tvnorms[btv->tvnorm].swidth;
		1959	maxh = bttv_tvnorms[btv->tvnorm].sheight;
		1960	field = f->fmt.pix.field;
		1961	if (V4L2_FIELD_ANY == field)
		1962	field = (f->fmt.pix.height > maxh/2)
		1963	? V4L2_FIELD_INTERLACED
		1964	: V4L2_FIELD_BOTTOM;
		1965	if (V4L2_FIELD_SEQ_BT == field)
		1966	field = V4L2_FIELD_SEQ_TB;
		1967	switch (field) {
		1968	case V4L2_FIELD_TOP:
		1969	case V4L2_FIELD_BOTTOM:
		1970	case V4L2_FIELD_ALTERNATE:
		1971	maxh = maxh/2;
		1972	break;
		1973	case V4L2_FIELD_INTERLACED:
		1974	break;
		1975	case V4L2_FIELD_SEQ_TB:
		1976	if (fmt->flags & FORMAT_FLAGS_PLANAR)
		1977	return -EINVAL;
		1978	break;
		1979	default:
		1980	return -EINVAL;
		1981	}
		1982
		1983	/* update data for the application */
		1984	f->fmt.pix.field = field;
		1985	if (f->fmt.pix.width < 48)
		1986	f->fmt.pix.width = 48;
		1987	if (f->fmt.pix.height < 32)
		1988	f->fmt.pix.height = 32;
		1989	if (f->fmt.pix.width > maxw)
		1990	f->fmt.pix.width = maxw;
		1991	if (f->fmt.pix.height > maxh)
		1992	f->fmt.pix.height = maxh;
		1993	f->fmt.pix.bytesperline =
		1994	(f->fmt.pix.width * fmt->depth) >> 3;
		1995	f->fmt.pix.sizeimage =
		1996	f->fmt.pix.height * f->fmt.pix.bytesperline;
		1997
		1998	return 0;
		1999	}
		2000	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
		2001	return verify_window(&bttv_tvnorms[btv->tvnorm],
		2002	&f->fmt.win, 1);
		2003	case V4L2_BUF_TYPE_VBI_CAPTURE:
516	giacomo	2004	//bttv_vbi_try_fmt(fh,f);
428	giacomo	2005	return 0;
		2006	default:
		2007	return -EINVAL;
		2008	}
170	giacomo	2009	}
		2010
428	giacomo	2011	static int bttv_s_fmt(struct bttv_fh fh, struct bttv btv,
		2012	struct v4l2_format *f)
170	giacomo	2013	{
428	giacomo	2014	int retval;
		2015
		2016	switch (f->type) {
		2017	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
		2018	{
		2019	const struct bttv_format *fmt;
170	giacomo	2020
428	giacomo	2021	retval = bttv_switch_type(fh,f->type);
		2022	if (0 != retval)
		2023	return retval;
		2024	retval = bttv_try_fmt(fh,btv,f);
		2025	if (0 != retval)
		2026	return retval;
		2027	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
		2028
		2029	/* update our state informations */
480	giacomo	2030	//down(&fh->cap.lock);
428	giacomo	2031	fh->fmt = fmt;
		2032	fh->cap.field = f->fmt.pix.field;
		2033	fh->cap.last = V4L2_FIELD_NONE;
		2034	fh->width = f->fmt.pix.width;
		2035	fh->height = f->fmt.pix.height;
		2036	btv->init.fmt = fmt;
		2037	btv->init.width = f->fmt.pix.width;
		2038	btv->init.height = f->fmt.pix.height;
480	giacomo	2039	//up(&fh->cap.lock);
428	giacomo	2040
		2041	return 0;
		2042	}
		2043	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
		2044	return setup_window(fh, btv, &f->fmt.win, 1);
		2045	case V4L2_BUF_TYPE_VBI_CAPTURE:
		2046	retval = bttv_switch_type(fh,f->type);
		2047	if (0 != retval)
		2048	return retval;
		2049	if (locked_btres(fh->btv, RESOURCE_VBI))
		2050	return -EBUSY;
516	giacomo	2051	//bttv_vbi_try_fmt(fh,f);
		2052	//bttv_vbi_setlines(fh,btv,f->fmt.vbi.count[0]);
		2053	//bttv_vbi_get_fmt(fh,f);
428	giacomo	2054	return 0;
		2055	default:
		2056	return -EINVAL;
		2057	}
170	giacomo	2058	}
		2059
516	giacomo	2060	int bttv_do_ioctl(struct inode inode, struct file file,
428	giacomo	2061	unsigned int cmd, void *arg)
170	giacomo	2062	{
428	giacomo	2063	struct bttv_fh *fh = file->private_data;
		2064	struct bttv *btv = fh->btv;
		2065	unsigned long flags;
		2066	int retval = 0;
170	giacomo	2067
428	giacomo	2068	if (bttv_debug > 1) {
		2069	switch (_IOC_TYPE(cmd)) {
		2070	case 'v':
516	giacomo	2071	//printk("bttv%d: ioctl 0x%x (v4l1, VIDIOC%s)\n",
		2072	// btv->nr, cmd, (_IOC_NR(cmd) < V4L1_IOCTLS) ?
		2073	// v4l1_ioctls[_IOC_NR(cmd)] : "???");
428	giacomo	2074	break;
		2075	case 'V':
516	giacomo	2076	//printk("bttv%d: ioctl 0x%x (v4l2, %s)\n",
		2077	// btv->nr, cmd, v4l2_ioctl_names[_IOC_NR(cmd)]);
428	giacomo	2078	break;
		2079	default:
		2080	printk("bttv%d: ioctl 0x%x ()\n",
		2081	btv->nr, cmd);
		2082	}
		2083	}
		2084	if (btv->errors)
		2085	bttv_reinit_bt848(btv);
170	giacomo	2086
428	giacomo	2087	#ifdef VIDIOC_G_PRIORITY
170	giacomo	2088	switch (cmd) {
428	giacomo	2089	case VIDIOCSFREQ:
		2090	case VIDIOCSTUNER:
		2091	case VIDIOCSCHAN:
		2092	case VIDIOC_S_CTRL:
		2093	case VIDIOC_S_STD:
		2094	case VIDIOC_S_INPUT:
		2095	case VIDIOC_S_TUNER:
		2096	case VIDIOC_S_FREQUENCY:
		2097	retval = v4l2_prio_check(&btv->prio,&fh->prio);
		2098	if (0 != retval)
		2099	return retval;
		2100	};
		2101	#endif
605	giacomo	2102
428	giacomo	2103	switch (cmd) {
		2104
		2105	/* * v4l1 * ************************************************ */
170	giacomo	2106	case VIDIOCGCAP:
		2107	{
428	giacomo	2108	struct video_capability *cap = arg;
		2109
		2110	memset(cap,0,sizeof(*cap));
		2111	strcpy(cap->name,btv->video_dev->name);
		2112	if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
		2113	/* vbi */
		2114	cap->type = VID_TYPE_TUNER\|VID_TYPE_TELETEXT;
		2115	} else {
		2116	/* others */
		2117	cap->type = VID_TYPE_CAPTURE\|
		2118	VID_TYPE_TUNER\|
		2119	VID_TYPE_OVERLAY\|
		2120	VID_TYPE_CLIPPING\|
		2121	VID_TYPE_SCALES;
		2122	cap->channels = bttv_tvcards[btv->type].video_inputs;
		2123	cap->audios = bttv_tvcards[btv->type].audio_inputs;
		2124	cap->maxwidth = bttv_tvnorms[btv->tvnorm].swidth;
		2125	cap->maxheight = bttv_tvnorms[btv->tvnorm].sheight;
		2126	cap->minwidth = 48;
		2127	cap->minheight = 32;
		2128	}
		2129	return 0;
170	giacomo	2130	}
428	giacomo	2131
		2132	case VIDIOCGPICT:
170	giacomo	2133	{
428	giacomo	2134	struct video_picture *pic = arg;
		2135
		2136	memset(pic,0,sizeof(*pic));
		2137	pic->brightness = btv->bright;
		2138	pic->contrast = btv->contrast;
		2139	pic->hue = btv->hue;
		2140	pic->colour = btv->saturation;
		2141	if (fh->fmt) {
		2142	pic->depth = fh->fmt->depth;
		2143	pic->palette = fh->fmt->palette;
		2144	}
170	giacomo	2145	return 0;
		2146	}
428	giacomo	2147	case VIDIOCSPICT:
170	giacomo	2148	{
428	giacomo	2149	struct video_picture *pic = arg;
		2150	const struct bttv_format *fmt;
170	giacomo	2151
428	giacomo	2152	fmt = format_by_palette(pic->palette);
		2153	if (NULL == fmt)
170	giacomo	2154	return -EINVAL;
480	giacomo	2155	//down(&fh->cap.lock);
428	giacomo	2156	if (fmt->depth != pic->depth && !sloppy) {
		2157	retval = -EINVAL;
		2158	goto fh_unlock_and_return;
		2159	}
		2160	fh->ovfmt = fmt;
		2161	fh->fmt = fmt;
		2162	btv->init.ovfmt = fmt;
		2163	btv->init.fmt = fmt;
		2164	if (bigendian) {
		2165	/* dirty hack time: swap bytes for overlay if the
		2166	display adaptor is big endian (insmod option) */
		2167	if (fmt->palette == VIDEO_PALETTE_RGB555 \|\|
		2168	fmt->palette == VIDEO_PALETTE_RGB565 \|\|
		2169	fmt->palette == VIDEO_PALETTE_RGB32) {
		2170	fh->ovfmt = fmt+1;
		2171	}
		2172	}
		2173	bt848_bright(btv,pic->brightness);
		2174	bt848_contrast(btv,pic->contrast);
		2175	bt848_hue(btv,pic->hue);
		2176	bt848_sat(btv,pic->colour);
480	giacomo	2177	//up(&fh->cap.lock);
428	giacomo	2178	return 0;
		2179	}
170	giacomo	2180
428	giacomo	2181	case VIDIOCGWIN:
		2182	{
		2183	struct video_window *win = arg;
		2184
		2185	memset(win,0,sizeof(*win));
		2186	win->x = fh->ov.w.left;
		2187	win->y = fh->ov.w.top;
		2188	win->width = fh->ov.w.width;
		2189	win->height = fh->ov.w.height;
170	giacomo	2190	return 0;
		2191	}
428	giacomo	2192	case VIDIOCSWIN:
170	giacomo	2193	{
428	giacomo	2194	struct video_window *win = arg;
		2195	struct v4l2_window w2;
		2196
		2197	w2.field = V4L2_FIELD_ANY;
		2198	w2.w.left = win->x;
		2199	w2.w.top = win->y;
		2200	w2.w.width = win->width;
		2201	w2.w.height = win->height;
		2202	w2.clipcount = win->clipcount;
		2203	w2.clips = (struct v4l2_clip*)win->clips;
		2204	retval = setup_window(fh, btv, &w2, 0);
		2205	if (0 == retval) {
		2206	/* on v4l1 this ioctl affects the read() size too */
		2207	fh->width = fh->ov.w.width;
		2208	fh->height = fh->ov.w.height;
		2209	btv->init.width = fh->ov.w.width;
		2210	btv->init.height = fh->ov.w.height;
		2211	}
		2212	return retval;
		2213	}
		2214
		2215	case VIDIOCGFBUF:
		2216	{
		2217	struct video_buffer *fbuf = arg;
		2218
		2219	fbuf->base = btv->fbuf.base;
		2220	fbuf->width = btv->fbuf.fmt.width;
		2221	fbuf->height = btv->fbuf.fmt.height;
		2222	fbuf->bytesperline = btv->fbuf.fmt.bytesperline;
		2223	if (fh->ovfmt)
		2224	fbuf->depth = fh->ovfmt->depth;
170	giacomo	2225	return 0;
		2226	}
428	giacomo	2227	case VIDIOCSFBUF:
170	giacomo	2228	{
428	giacomo	2229	struct video_buffer *fbuf = arg;
		2230	const struct bttv_format *fmt;
		2231	unsigned long end;
		2232
		2233	end = (unsigned long)fbuf->base +
		2234	fbuf->height * fbuf->bytesperline;
480	giacomo	2235	//down(&fh->cap.lock);
428	giacomo	2236	retval = -EINVAL;
		2237	if (sloppy) {
		2238	/* also set the default palette -- for backward
		2239	compatibility with older versions */
		2240	switch (fbuf->depth) {
		2241	case 8:
		2242	fmt = format_by_palette(VIDEO_PALETTE_HI240);
		2243	break;
		2244	case 16:
		2245	fmt = format_by_palette(VIDEO_PALETTE_RGB565);
		2246	break;
		2247	case 24:
		2248	fmt = format_by_palette(VIDEO_PALETTE_RGB24);
		2249	break;
		2250	case 32:
		2251	fmt = format_by_palette(VIDEO_PALETTE_RGB32);
		2252	break;
		2253	case 15:
		2254	fbuf->depth = 16;
		2255	fmt = format_by_palette(VIDEO_PALETTE_RGB555);
		2256	break;
		2257	default:
		2258	fmt = NULL;
		2259	break;
		2260	}
		2261	if (NULL == fmt)
		2262	goto fh_unlock_and_return;
		2263	fh->ovfmt = fmt;
		2264	fh->fmt = fmt;
		2265	btv->init.ovfmt = fmt;
		2266	btv->init.fmt = fmt;
		2267	} else {
		2268	if (15 == fbuf->depth)
		2269	fbuf->depth = 16;
		2270	if (fbuf->depth != 8 && fbuf->depth != 16 &&
		2271	fbuf->depth != 24 && fbuf->depth != 32)
		2272	goto fh_unlock_and_return;
170	giacomo	2273	}
428	giacomo	2274	btv->fbuf.base = fbuf->base;
		2275	btv->fbuf.fmt.width = fbuf->width;
		2276	btv->fbuf.fmt.height = fbuf->height;
		2277	if (fbuf->bytesperline)
		2278	btv->fbuf.fmt.bytesperline = fbuf->bytesperline;
		2279	else
		2280	btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fbuf->depth/8;
480	giacomo	2281	//up(&fh->cap.lock);
170	giacomo	2282	return 0;
		2283	}
428	giacomo	2284
		2285	case VIDIOCCAPTURE:
		2286	case VIDIOC_OVERLAY:
170	giacomo	2287	{
428	giacomo	2288	struct bttv_buffer *new;
		2289	int *on = arg;
		2290
		2291	if (*on) {
		2292	/* verify args */
		2293	if (NULL == btv->fbuf.base)
		2294	return -EINVAL;
		2295	if (!fh->ov.setup_ok) {
623	giacomo	2296	//dprintk("bttv%d: overlay: !setup_ok\n",btv->nr);
428	giacomo	2297	return -EINVAL;
		2298	}
		2299	}
		2300
		2301	if (!check_alloc_btres(btv,fh,RESOURCE_OVERLAY))
		2302	return -EBUSY;
		2303
480	giacomo	2304	//down(&fh->cap.lock);
428	giacomo	2305	if (*on) {
		2306	fh->ov.tvnorm = btv->tvnorm;
		2307	new = videobuf_alloc(sizeof(*new));
		2308	bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
		2309	} else {
		2310	new = NULL;
		2311	}
		2312
		2313	/* switch over */
		2314	retval = bttv_switch_overlay(btv,fh,new);
480	giacomo	2315	//up(&fh->cap.lock);
428	giacomo	2316	return retval;
		2317	}
		2318
		2319	case VIDIOCGMBUF:
		2320	{
		2321	struct video_mbuf *mbuf = arg;
		2322	unsigned int i;
		2323
480	giacomo	2324	//down(&fh->cap.lock);
428	giacomo	2325	retval = videobuf_mmap_setup(file,&fh->cap,gbuffers,gbufsize,
		2326	V4L2_MEMORY_MMAP);
		2327	if (retval < 0)
		2328	goto fh_unlock_and_return;
		2329	memset(mbuf,0,sizeof(*mbuf));
		2330	mbuf->frames = gbuffers;
		2331	mbuf->size = gbuffers * gbufsize;
		2332	for (i = 0; i < gbuffers; i++)
		2333	mbuf->offsets[i] = i * gbufsize;
480	giacomo	2334	//up(&fh->cap.lock);
170	giacomo	2335	return 0;
		2336	}
428	giacomo	2337	case VIDIOCMCAPTURE:
170	giacomo	2338	{
428	giacomo	2339	struct video_mmap *vm = arg;
		2340	struct bttv_buffer *buf;
		2341	enum v4l2_field field;
		2342
		2343	if (vm->frame >= VIDEO_MAX_FRAME)
170	giacomo	2344	return -EINVAL;
428	giacomo	2345
480	giacomo	2346	//down(&fh->cap.lock);
428	giacomo	2347	retval = -EINVAL;
		2348	buf = (struct bttv_buffer *)fh->cap.bufs[vm->frame];
		2349	if (NULL == buf)
		2350	goto fh_unlock_and_return;
606	giacomo	2351
428	giacomo	2352	if (0 == buf->vb.baddr)
		2353	goto fh_unlock_and_return;
541	giacomo	2354
428	giacomo	2355	if (buf->vb.state == STATE_QUEUED \|\|
		2356	buf->vb.state == STATE_ACTIVE)
		2357	goto fh_unlock_and_return;
		2358
		2359	field = (vm->height > bttv_tvnorms[btv->tvnorm].sheight/2)
		2360	? V4L2_FIELD_INTERLACED
		2361	: V4L2_FIELD_BOTTOM;
		2362	retval = bttv_prepare_buffer(btv,buf,
		2363	format_by_palette(vm->format),
		2364	vm->width,vm->height,field);
		2365	if (0 != retval)
		2366	goto fh_unlock_and_return;
		2367	spin_lock_irqsave(&btv->s_lock,flags);
		2368	buffer_queue(file,&buf->vb);
		2369	spin_unlock_irqrestore(&btv->s_lock,flags);
480	giacomo	2370	//up(&fh->cap.lock);
170	giacomo	2371	return 0;
		2372	}
428	giacomo	2373	case VIDIOCSYNC:
170	giacomo	2374	{
		2375
695	giacomo	2376	/* S.Ha.R.K. Version: Active wait until complete */
170	giacomo	2377
696	giacomo	2378	int pid = (int)(arg);
695	giacomo	2379
696	giacomo	2380	if (pid != -1) grab_task = pid;
695	giacomo	2381
696	giacomo	2382	return grab_task;
695	giacomo	2383
170	giacomo	2384	}
428	giacomo	2385
		2386	case VIDIOCGVBIFMT:
170	giacomo	2387	{
428	giacomo	2388	struct vbi_format fmt = (void ) arg;
		2389	struct v4l2_format fmt2;
		2390
		2391	if (fh->type != V4L2_BUF_TYPE_VBI_CAPTURE) {
		2392	retval = bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
		2393	if (0 != retval)
		2394	return retval;
		2395	}
516	giacomo	2396	//bttv_vbi_get_fmt(fh, &fmt2);
428	giacomo	2397
		2398	memset(fmt,0,sizeof(*fmt));
		2399	fmt->sampling_rate = fmt2.fmt.vbi.sampling_rate;
		2400	fmt->samples_per_line = fmt2.fmt.vbi.samples_per_line;
		2401	fmt->sample_format = VIDEO_PALETTE_RAW;
		2402	fmt->start[0] = fmt2.fmt.vbi.start[0];
		2403	fmt->count[0] = fmt2.fmt.vbi.count[0];
		2404	fmt->start[1] = fmt2.fmt.vbi.start[1];
		2405	fmt->count[1] = fmt2.fmt.vbi.count[1];
		2406	if (fmt2.fmt.vbi.flags & VBI_UNSYNC)
		2407	fmt->flags \|= V4L2_VBI_UNSYNC;
		2408	if (fmt2.fmt.vbi.flags & VBI_INTERLACED)
		2409	fmt->flags \|= V4L2_VBI_INTERLACED;
170	giacomo	2410	return 0;
		2411	}
428	giacomo	2412	case VIDIOCSVBIFMT:
170	giacomo	2413	{
428	giacomo	2414	struct vbi_format fmt = (void ) arg;
		2415	struct v4l2_format fmt2;
		2416
		2417	retval = bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
		2418	if (0 != retval)
		2419	return retval;
516	giacomo	2420	//bttv_vbi_get_fmt(fh, &fmt2);
428	giacomo	2421
		2422	if (fmt->sampling_rate != fmt2.fmt.vbi.sampling_rate \|\|
		2423	fmt->samples_per_line != fmt2.fmt.vbi.samples_per_line \|\|
		2424	fmt->sample_format != VIDEO_PALETTE_RAW \|\|
		2425	fmt->start[0] != fmt2.fmt.vbi.start[0] \|\|
		2426	fmt->start[1] != fmt2.fmt.vbi.start[1] \|\|
		2427	fmt->count[0] != fmt->count[1] \|\|
		2428	fmt->count[0] < 1 \|\|
		2429	fmt->count[0] > 32 /* VBI_MAXLINES */)
170	giacomo	2430	return -EINVAL;
428	giacomo	2431
516	giacomo	2432	//bttv_vbi_setlines(fh,btv,fmt->count[0]);
170	giacomo	2433	return 0;
		2434	}
428	giacomo	2435
		2436	case BTTV_VERSION:
		2437	case VIDIOCGFREQ:
		2438	case VIDIOCSFREQ:
		2439	case VIDIOCGTUNER:
		2440	case VIDIOCSTUNER:
		2441	case VIDIOCGCHAN:
		2442	case VIDIOCSCHAN:
		2443	case VIDIOCGAUDIO:
		2444	case VIDIOCSAUDIO:
		2445	return bttv_common_ioctls(btv,cmd,arg);
		2446
		2447	/* * v4l2 * ************************************************ */
		2448	case VIDIOC_QUERYCAP:
170	giacomo	2449	{
428	giacomo	2450	struct v4l2_capability *cap = arg;
		2451
		2452	if (0 == v4l2)
		2453	return -EINVAL;
		2454	strcpy(cap->driver,"bttv");
516	giacomo	2455	strncpy(cap->card,btv->video_dev->name,sizeof(cap->card));
463	giacomo	2456	sprintf26(cap->bus_info,"PCI:%s",pci_name(btv->dev));
428	giacomo	2457	cap->version = BTTV_VERSION_CODE;
		2458	cap->capabilities =
		2459	V4L2_CAP_VIDEO_CAPTURE \|
		2460	V4L2_CAP_VIDEO_OVERLAY \|
		2461	V4L2_CAP_VBI_CAPTURE \|
		2462	V4L2_CAP_TUNER \|
		2463	V4L2_CAP_READWRITE \|
		2464	V4L2_CAP_STREAMING;
170	giacomo	2465	return 0;
		2466	}
428	giacomo	2467
		2468	case VIDIOC_ENUM_FMT:
170	giacomo	2469	{
428	giacomo	2470	struct v4l2_fmtdesc *f = arg;
		2471	enum v4l2_buf_type type;
		2472	unsigned int i;
		2473	int index;
		2474
		2475	type = f->type;
		2476	if (V4L2_BUF_TYPE_VBI_CAPTURE == type) {
		2477	/* vbi */
		2478	index = f->index;
		2479	if (0 != index)
		2480	return -EINVAL;
		2481	memset(f,0,sizeof(*f));
		2482	f->index = index;
		2483	f->type = type;
		2484	f->pixelformat = V4L2_PIX_FMT_GREY;
		2485	strcpy(f->description,"vbi data");
		2486	return 0;
		2487	}
		2488
		2489	/* video capture + overlay */
		2490	index = -1;
		2491	for (i = 0; i < BTTV_FORMATS; i++) {
		2492	if (bttv_formats[i].fourcc != -1)
		2493	index++;
		2494	if ((unsigned int)index == f->index)
		2495	break;
		2496	}
		2497	if (BTTV_FORMATS == i)
170	giacomo	2498	return -EINVAL;
		2499
428	giacomo	2500	switch (f->type) {
		2501	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
		2502	break;
		2503	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
		2504	if (!(bttv_formats[i].flags & FORMAT_FLAGS_PACKED))
		2505	return -EINVAL;
		2506	break;
		2507	default:
		2508	return -EINVAL;
170	giacomo	2509	}
428	giacomo	2510	memset(f,0,sizeof(*f));
		2511	f->index = index;
		2512	f->type = type;
		2513	f->pixelformat = bttv_formats[i].fourcc;
516	giacomo	2514	strncpy(f->description,bttv_formats[i].name,sizeof(f->description));
428	giacomo	2515	return 0;
170	giacomo	2516	}
428	giacomo	2517
		2518	case VIDIOC_TRY_FMT:
170	giacomo	2519	{
428	giacomo	2520	struct v4l2_format *f = arg;
		2521	return bttv_try_fmt(fh,btv,f);
170	giacomo	2522	}
428	giacomo	2523	case VIDIOC_G_FMT:
170	giacomo	2524	{
428	giacomo	2525	struct v4l2_format *f = arg;
		2526	return bttv_g_fmt(fh,f);
170	giacomo	2527	}
428	giacomo	2528	case VIDIOC_S_FMT:
170	giacomo	2529	{
428	giacomo	2530	struct v4l2_format *f = arg;
		2531	return bttv_s_fmt(fh,btv,f);
		2532	}
		2533
		2534	case VIDIOC_G_FBUF:
		2535	{
		2536	struct v4l2_framebuffer *fb = arg;
		2537
		2538	*fb = btv->fbuf;
		2539	fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
		2540	if (fh->ovfmt)
		2541	fb->fmt.pixelformat = fh->ovfmt->fourcc;
170	giacomo	2542	return 0;
		2543	}
428	giacomo	2544	case VIDIOC_S_FBUF:
170	giacomo	2545	{
428	giacomo	2546	struct v4l2_framebuffer *fb = arg;
		2547	const struct bttv_format *fmt;
170	giacomo	2548
428	giacomo	2549	/* check args */
		2550	fmt = format_by_fourcc(fb->fmt.pixelformat);
		2551	if (NULL == fmt)
		2552	return -EINVAL;
		2553	if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
		2554	return -EINVAL;
		2555
480	giacomo	2556	//down(&fh->cap.lock);
428	giacomo	2557	retval = -EINVAL;
		2558	if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
		2559	if (fb->fmt.width > bttv_tvnorms[btv->tvnorm].swidth)
		2560	goto fh_unlock_and_return;
		2561	if (fb->fmt.height > bttv_tvnorms[btv->tvnorm].sheight)
		2562	goto fh_unlock_and_return;
		2563	}
		2564
		2565	/* ok, accept it */
		2566	btv->fbuf.base = fb->base;
		2567	btv->fbuf.fmt.width = fb->fmt.width;
		2568	btv->fbuf.fmt.height = fb->fmt.height;
		2569	if (0 != fb->fmt.bytesperline)
		2570	btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
		2571	else
		2572	btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
		2573
		2574	retval = 0;
		2575	fh->ovfmt = fmt;
		2576	btv->init.ovfmt = fmt;
		2577	if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
		2578	fh->ov.w.left = 0;
		2579	fh->ov.w.top = 0;
		2580	fh->ov.w.width = fb->fmt.width;
		2581	fh->ov.w.height = fb->fmt.height;
		2582	btv->init.ov.w.width = fb->fmt.width;
		2583	btv->init.ov.w.height = fb->fmt.height;
		2584	if (fh->ov.clips)
		2585	kfree(fh->ov.clips);
		2586	fh->ov.clips = NULL;
		2587	fh->ov.nclips = 0;
		2588
		2589	if (check_btres(fh, RESOURCE_OVERLAY)) {
		2590	struct bttv_buffer *new;
		2591
		2592	new = videobuf_alloc(sizeof(*new));
		2593	bttv_overlay_risc(btv,&fh->ov,fh->ovfmt,new);
		2594	retval = bttv_switch_overlay(btv,fh,new);
		2595	}
		2596	}
480	giacomo	2597	//up(&fh->cap.lock);
428	giacomo	2598	return retval;
170	giacomo	2599	}
		2600
428	giacomo	2601	case VIDIOC_REQBUFS:
		2602	return videobuf_reqbufs(file,bttv_queue(fh),arg);
		2603
		2604	case VIDIOC_QUERYBUF:
		2605	return videobuf_querybuf(bttv_queue(fh),arg);
		2606
		2607	case VIDIOC_QBUF:
		2608	return videobuf_qbuf(file,bttv_queue(fh),arg);
		2609
		2610	case VIDIOC_DQBUF:
		2611	return videobuf_dqbuf(file,bttv_queue(fh),arg);
		2612
		2613	case VIDIOC_STREAMON:
170	giacomo	2614	{
428	giacomo	2615	int res = bttv_resource(fh);
		2616
		2617	if (!check_alloc_btres(btv,fh,res))
		2618	return -EBUSY;
		2619	return videobuf_streamon(file,bttv_queue(fh));
170	giacomo	2620	}
428	giacomo	2621	case VIDIOC_STREAMOFF:
170	giacomo	2622	{
428	giacomo	2623	int res = bttv_resource(fh);
		2624
		2625	retval = videobuf_streamoff(file,bttv_queue(fh));
		2626	if (retval < 0)
		2627	return retval;
		2628	free_btres(btv,fh,res);
170	giacomo	2629	return 0;
		2630	}
428	giacomo	2631
		2632	case VIDIOC_QUERYCTRL:
170	giacomo	2633	{
428	giacomo	2634	struct v4l2_queryctrl *c = arg;
		2635	int i;
		2636
		2637	if ((c->id < V4L2_CID_BASE \|\|
		2638	c->id >= V4L2_CID_LASTP1) &&
		2639	(c->id < V4L2_CID_PRIVATE_BASE \|\|
		2640	c->id >= V4L2_CID_PRIVATE_LASTP1))
		2641	return -EINVAL;
		2642	for (i = 0; i < BTTV_CTLS; i++)
		2643	if (bttv_ctls[i].id == c->id)
		2644	break;
		2645	if (i == BTTV_CTLS) {
		2646	*c = no_ctl;
		2647	return 0;
		2648	}
		2649	*c = bttv_ctls[i];
		2650	if (i >= 4 && i <= 8) {
		2651	struct video_audio va;
		2652	memset(&va,0,sizeof(va));
		2653	bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
		2654	if (btv->audio_hook)
		2655	btv->audio_hook(btv,&va,0);
		2656	switch (bttv_ctls[i].id) {
		2657	case V4L2_CID_AUDIO_VOLUME:
		2658	if (!(va.flags & VIDEO_AUDIO_VOLUME))
		2659	*c = no_ctl;
		2660	break;
		2661	case V4L2_CID_AUDIO_BALANCE:
		2662	if (!(va.flags & VIDEO_AUDIO_BALANCE))
		2663	*c = no_ctl;
		2664	break;
		2665	case V4L2_CID_AUDIO_BASS:
		2666	if (!(va.flags & VIDEO_AUDIO_BASS))
		2667	*c = no_ctl;
		2668	break;
		2669	case V4L2_CID_AUDIO_TREBLE:
		2670	if (!(va.flags & VIDEO_AUDIO_TREBLE))
		2671	*c = no_ctl;
		2672	break;
		2673	}
		2674	}
170	giacomo	2675	return 0;
		2676	}
428	giacomo	2677	case VIDIOC_G_CTRL:
		2678	return get_control(btv,arg);
		2679	case VIDIOC_S_CTRL:
		2680	return set_control(btv,arg);
		2681	case VIDIOC_G_PARM:
170	giacomo	2682	{
428	giacomo	2683	struct v4l2_streamparm *parm = arg;
		2684	struct v4l2_standard s;
		2685	if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
		2686	return -EINVAL;
		2687	memset(parm,0,sizeof(*parm));
516	giacomo	2688	//v4l2_video_std_construct(&s, bttv_tvnorms[btv->tvnorm].v4l2_id,
		2689	// bttv_tvnorms[btv->tvnorm].name);
428	giacomo	2690	parm->parm.capture.timeperframe = s.frameperiod;
170	giacomo	2691	return 0;
		2692	}
		2693
428	giacomo	2694	#ifdef VIDIOC_G_PRIORITY
		2695	case VIDIOC_G_PRIORITY:
170	giacomo	2696	{
428	giacomo	2697	enum v4l2_priority *p = arg;
170	giacomo	2698
428	giacomo	2699	*p = v4l2_prio_max(&btv->prio);
170	giacomo	2700	return 0;
		2701	}
428	giacomo	2702	case VIDIOC_S_PRIORITY:
170	giacomo	2703	{
428	giacomo	2704	enum v4l2_priority *prio = arg;
		2705
		2706	return v4l2_prio_change(&btv->prio, &fh->prio, *prio);
170	giacomo	2707	}
428	giacomo	2708	#endif
170	giacomo	2709
428	giacomo	2710
		2711	case VIDIOC_ENUMSTD:
		2712	case VIDIOC_G_STD:
		2713	case VIDIOC_S_STD:
		2714	case VIDIOC_ENUMINPUT:
		2715	case VIDIOC_G_INPUT:
		2716	case VIDIOC_S_INPUT:
		2717	case VIDIOC_G_TUNER:
		2718	case VIDIOC_S_TUNER:
		2719	case VIDIOC_G_FREQUENCY:
		2720	case VIDIOC_S_FREQUENCY:
		2721	return bttv_common_ioctls(btv,cmd,arg);
		2722
170	giacomo	2723	default:
428	giacomo	2724	return -ENOIOCTLCMD;
170	giacomo	2725	}
		2726	return 0;
428	giacomo	2727
		2728	fh_unlock_and_return:
480	giacomo	2729	//up(&fh->cap.lock);
428	giacomo	2730	return retval;
170	giacomo	2731	}
		2732
516	giacomo	2733	int bttv_ioctl(struct inode inode, struct file file,
428	giacomo	2734	unsigned int cmd, unsigned long arg)
170	giacomo	2735	{
428	giacomo	2736	struct bttv_fh *fh = file->private_data;
		2737
		2738	switch (cmd) {
		2739	case BTTV_VBISIZE:
		2740	bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
		2741	return fh->lines * 2 * 2048;
		2742	default:
541	giacomo	2743	return bttv_do_ioctl(inode, file, cmd, (void *)arg);
		2744	//video_usercopy(inode, file, cmd, arg, bttv_do_ioctl);
170	giacomo	2745	}
428	giacomo	2746	}
170	giacomo	2747
516	giacomo	2748	ssize_t bttv_read(struct file file, char data,
428	giacomo	2749	size_t count, loff_t *ppos)
		2750	{
		2751	struct bttv_fh *fh = file->private_data;
		2752	int retval = 0;
170	giacomo	2753
428	giacomo	2754	if (fh->btv->errors)
		2755	bttv_reinit_bt848(fh->btv);
516	giacomo	2756	//dprintk("bttv%d: read count=%d type=%s\n",
		2757	// fh->btv->nr,(int)count,v4l2_type_names[fh->type]);
170	giacomo	2758
428	giacomo	2759	switch (fh->type) {
		2760	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
		2761	if (locked_btres(fh->btv,RESOURCE_VIDEO))
		2762	return -EBUSY;
		2763	retval = videobuf_read_one(file, &fh->cap, data, count, ppos);
		2764	break;
		2765	case V4L2_BUF_TYPE_VBI_CAPTURE:
		2766	if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
		2767	return -EBUSY;
		2768	retval = videobuf_read_stream(file, &fh->vbi, data, count, ppos, 1);
		2769	break;
		2770	default:
		2771	BUG();
170	giacomo	2772	}
428	giacomo	2773	return retval;
		2774	}
170	giacomo	2775
491	giacomo	2776	/*
428	giacomo	2777	static unsigned int bttv_poll(struct file file, poll_table wait)
		2778	{
		2779	struct bttv_fh *fh = file->private_data;
		2780	struct bttv_buffer *buf;
		2781	enum v4l2_field field;
		2782
		2783	if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
		2784	if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
		2785	return -EBUSY;
		2786	return videobuf_poll_stream(file, &fh->vbi, wait);
		2787	}
		2788
		2789	if (check_btres(fh,RESOURCE_VIDEO)) {
		2790	if (list_empty(&fh->cap.stream))
		2791	return POLLERR;
		2792	buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
170	giacomo	2793	} else {
480	giacomo	2794	//down(&fh->cap.lock);
428	giacomo	2795	if (NULL == fh->cap.read_buf) {
		2796	if (locked_btres(fh->btv,RESOURCE_VIDEO)) {
480	giacomo	2797	//up(&fh->cap.lock);
428	giacomo	2798	return POLLERR;
		2799	}
		2800	fh->cap.read_buf = videobuf_alloc(fh->cap.msize);
		2801	if (NULL == fh->cap.read_buf) {
480	giacomo	2802	//up(&fh->cap.lock);
428	giacomo	2803	return POLLERR;
		2804	}
		2805	fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
		2806	field = videobuf_next_field(&fh->cap);
		2807	if (0 != fh->cap.ops->buf_prepare(file,fh->cap.read_buf,field)) {
480	giacomo	2808	//up(&fh->cap.lock);
428	giacomo	2809	return POLLERR;
		2810	}
		2811	fh->cap.ops->buf_queue(file,fh->cap.read_buf);
		2812	fh->cap.read_off = 0;
		2813	}
480	giacomo	2814	//up(&fh->cap.lock);
428	giacomo	2815	buf = (struct bttv_buffer*)fh->cap.read_buf;
170	giacomo	2816	}
428	giacomo	2817
491	giacomo	2818	//poll_wait(file, &buf->vb.done, wait);
428	giacomo	2819	if (buf->vb.state == STATE_DONE \|\|
		2820	buf->vb.state == STATE_ERROR)
		2821	return POLLIN\|POLLRDNORM;
		2822	return 0;
		2823	}
491	giacomo	2824	*/
170	giacomo	2825
516	giacomo	2826	int bttv_open(struct inode inode, struct file file)
428	giacomo	2827	{
		2828	int minor = iminor(inode);
		2829	struct bttv *btv = NULL;
		2830	struct bttv_fh *fh;
		2831	enum v4l2_buf_type type = 0;
		2832	unsigned int i;
170	giacomo	2833
428	giacomo	2834	dprintk(KERN_DEBUG "bttv: open minor=%d\n",minor);
170	giacomo	2835
428	giacomo	2836	for (i = 0; i < bttv_num; i++) {
		2837	if (bttvs[i].video_dev->minor == minor) {
		2838	btv = &bttvs[i];
		2839	type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		2840	break;
		2841	}
		2842	if (bttvs[i].vbi_dev->minor == minor) {
		2843	btv = &bttvs[i];
		2844	type = V4L2_BUF_TYPE_VBI_CAPTURE;
		2845	break;
		2846	}
170	giacomo	2847	}
428	giacomo	2848	if (NULL == btv)
		2849	return -ENODEV;
170	giacomo	2850
516	giacomo	2851	//dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
		2852	// btv->nr,v4l2_type_names[type]);
428	giacomo	2853
		2854	/* allocate per filehandle data */
		2855	fh = kmalloc(sizeof(*fh),GFP_KERNEL);
		2856	if (NULL == fh)
		2857	return -ENOMEM;
		2858	file->private_data = fh;
		2859	*fh = btv->init;
		2860	fh->type = type;
		2861	fh->ov.setup_ok = 0;
		2862	#ifdef VIDIOC_G_PRIORITY
		2863	v4l2_prio_open(&btv->prio,&fh->prio);
		2864	#endif
516	giacomo	2865
428	giacomo	2866	videobuf_queue_init(&fh->cap, &bttv_video_qops,
		2867	btv->dev, &btv->s_lock,
		2868	V4L2_BUF_TYPE_VIDEO_CAPTURE,
		2869	V4L2_FIELD_INTERLACED,
		2870	sizeof(struct bttv_buffer));
516	giacomo	2871	/*
428	giacomo	2872	videobuf_queue_init(&fh->vbi, &bttv_vbi_qops,
		2873	btv->dev, &btv->s_lock,
		2874	V4L2_BUF_TYPE_VBI_CAPTURE,
		2875	V4L2_FIELD_SEQ_TB,
		2876	sizeof(struct bttv_buffer));
516	giacomo	2877	*/
428	giacomo	2878	i2c_vidiocschan(btv);
		2879
		2880	btv->users++;
516	giacomo	2881	//if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type)
		2882	//bttv_vbi_setlines(fh,btv,16);
621	giacomo	2883	//bttv_field_count(btv);
428	giacomo	2884	return 0;
		2885	}
		2886
516	giacomo	2887	int bttv_release(struct inode inode, struct file file)
428	giacomo	2888	{
		2889	struct bttv_fh *fh = file->private_data;
		2890	struct bttv *btv = fh->btv;
		2891
		2892	/* turn off overlay */
		2893	if (check_btres(fh, RESOURCE_OVERLAY))
		2894	bttv_switch_overlay(btv,fh,NULL);
		2895
		2896	/* stop video capture */
		2897	if (check_btres(fh, RESOURCE_VIDEO)) {
		2898	videobuf_streamoff(file,&fh->cap);
		2899	free_btres(btv,fh,RESOURCE_VIDEO);
170	giacomo	2900	}
428	giacomo	2901	if (fh->cap.read_buf) {
		2902	buffer_release(file,fh->cap.read_buf);
		2903	kfree(fh->cap.read_buf);
		2904	}
170	giacomo	2905
428	giacomo	2906	/* stop vbi capture */
		2907	if (check_btres(fh, RESOURCE_VBI)) {
		2908	if (fh->vbi.streaming)
		2909	videobuf_streamoff(file,&fh->vbi);
		2910	if (fh->vbi.reading)
		2911	videobuf_read_stop(file,&fh->vbi);
		2912	free_btres(btv,fh,RESOURCE_VBI);
170	giacomo	2913	}
		2914
428	giacomo	2915	#ifdef VIDIOC_G_PRIORITY
		2916	v4l2_prio_close(&btv->prio,&fh->prio);
		2917	#endif
		2918	file->private_data = NULL;
		2919	kfree(fh);
		2920
		2921	btv->users--;
621	giacomo	2922	//bttv_field_count(btv);
428	giacomo	2923	return 0;
170	giacomo	2924	}
		2925
516	giacomo	2926	int
428	giacomo	2927	bttv_mmap(struct file file, struct vm_area_struct vma)
170	giacomo	2928	{
428	giacomo	2929	struct bttv_fh *fh = file->private_data;
170	giacomo	2930
516	giacomo	2931	//dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
		2932	// fh->btv->nr, v4l2_type_names[fh->type],
		2933	// vma->vm_start, vma->vm_end - vma->vm_start);
428	giacomo	2934	return videobuf_mmap_mapper(vma,bttv_queue(fh));
		2935	}
541	giacomo	2936
428	giacomo	2937	static struct file_operations bttv_fops =
		2938	{
		2939	.owner = THIS_MODULE,
		2940	.open = bttv_open,
		2941	.release = bttv_release,
		2942	.ioctl = bttv_ioctl,
		2943	.llseek = no_llseek,
		2944	.read = bttv_read,
		2945	.mmap = bttv_mmap,
		2946	};
541	giacomo	2947
		2948
428	giacomo	2949	static struct video_device bttv_video_template =
		2950	{
		2951	.name = "UNSET",
		2952	.type = VID_TYPE_CAPTURE\|VID_TYPE_TUNER\|VID_TYPE_OVERLAY\|
		2953	VID_TYPE_CLIPPING\|VID_TYPE_SCALES,
		2954	.hardware = VID_HARDWARE_BT848,
		2955	.fops = &bttv_fops,
		2956	.minor = -1,
		2957	};
541	giacomo	2958	/*
428	giacomo	2959	struct video_device bttv_vbi_template =
		2960	{
		2961	.name = "bt848/878 vbi",
		2962	.type = VID_TYPE_TUNER\|VID_TYPE_TELETEXT,
		2963	.hardware = VID_HARDWARE_BT848,
		2964	.fops = &bttv_fops,
		2965	.minor = -1,
		2966	};
516	giacomo	2967	*/
428	giacomo	2968	/* ----------------------------------------------------------------------- */
		2969	/* radio interface */
170	giacomo	2970
516	giacomo	2971	int radio_open(struct inode inode, struct file file)
428	giacomo	2972	{
		2973	int minor = iminor(inode);
		2974	struct bttv *btv = NULL;
		2975	unsigned int i;
170	giacomo	2976
428	giacomo	2977	dprintk("bttv: open minor=%d\n",minor);
170	giacomo	2978
428	giacomo	2979	for (i = 0; i < bttv_num; i++) {
		2980	if (bttvs[i].radio_dev->minor == minor) {
		2981	btv = &bttvs[i];
		2982	break;
		2983	}
		2984	}
		2985	if (NULL == btv)
		2986	return -ENODEV;
170	giacomo	2987
428	giacomo	2988	dprintk("bttv%d: open called (radio)\n",btv->nr);
480	giacomo	2989	//down(&btv->lock);
428	giacomo	2990	if (btv->radio_user) {
480	giacomo	2991	//up(&btv->lock);
428	giacomo	2992	return -EBUSY;
		2993	}
		2994	btv->radio_user++;
		2995	file->private_data = btv;
170	giacomo	2996
428	giacomo	2997	i2c_vidiocschan(btv);
		2998	bttv_call_i2c_clients(btv,AUDC_SET_RADIO,&btv->tuner_type);
		2999	audio_mux(btv,AUDIO_RADIO);
		3000
480	giacomo	3001	//up(&btv->lock);
428	giacomo	3002	return 0;
		3003	}
		3004
516	giacomo	3005	int radio_release(struct inode inode, struct file file)
428	giacomo	3006	{
		3007	struct bttv *btv = file->private_data;
		3008
		3009	btv->radio_user--;
		3010	return 0;
		3011	}
		3012
516	giacomo	3013	int radio_do_ioctl(struct inode inode, struct file file,
428	giacomo	3014	unsigned int cmd, void *arg)
		3015	{
		3016	struct bttv *btv = file->private_data;
		3017
		3018	switch (cmd) {
		3019	case VIDIOCGCAP:
		3020	{
		3021	struct video_capability *cap = arg;
		3022
		3023	memset(cap,0,sizeof(*cap));
		3024	strcpy(cap->name,btv->radio_dev->name);
		3025	cap->type = VID_TYPE_TUNER;
		3026	cap->channels = 1;
		3027	cap->audios = 1;
		3028	return 0;
170	giacomo	3029	}
428	giacomo	3030
		3031	case VIDIOCGTUNER:
		3032	{
		3033	struct video_tuner *v = arg;
		3034
		3035	if(v->tuner)
		3036	return -EINVAL;
		3037	memset(v,0,sizeof(*v));
		3038	strcpy(v->name, "Radio");
		3039	/* japan: 76.0 MHz - 89.9 MHz
		3040	western europe: 87.5 MHz - 108.0 MHz
		3041	russia: 65.0 MHz - 108.0 MHz */
		3042	v->rangelow=(int)(65*16);
		3043	v->rangehigh=(int)(108*16);
		3044	bttv_call_i2c_clients(btv,cmd,v);
		3045	return 0;
		3046	}
		3047	case VIDIOCSTUNER:
		3048	/* nothing to do */
		3049	return 0;
170	giacomo	3050
428	giacomo	3051	case BTTV_VERSION:
		3052	case VIDIOCGFREQ:
		3053	case VIDIOCSFREQ:
		3054	case VIDIOCGAUDIO:
		3055	case VIDIOCSAUDIO:
		3056	return bttv_common_ioctls(btv,cmd,arg);
170	giacomo	3057
428	giacomo	3058	default:
		3059	return -ENOIOCTLCMD;
		3060	}
		3061	return 0;
		3062	}
170	giacomo	3063
516	giacomo	3064	int radio_ioctl(struct inode inode, struct file file,
428	giacomo	3065	unsigned int cmd, unsigned long arg)
		3066	{
516	giacomo	3067	return 0;//video_usercopy(inode, file, cmd, arg, radio_do_ioctl);
428	giacomo	3068	}
541	giacomo	3069
428	giacomo	3070	static struct file_operations radio_fops =
		3071	{
		3072	.owner = THIS_MODULE,
		3073	.open = radio_open,
		3074	.release = radio_release,
		3075	.ioctl = radio_ioctl,
		3076	.llseek = no_llseek,
		3077	};
541	giacomo	3078
		3079
428	giacomo	3080	static struct video_device radio_template =
		3081	{
		3082	.name = "bt848/878 radio",
		3083	.type = VID_TYPE_TUNER,
		3084	.hardware = VID_HARDWARE_BT848,
		3085	.fops = &radio_fops,
		3086	.minor = -1,
		3087	};
541	giacomo	3088
428	giacomo	3089	/* ----------------------------------------------------------------------- */
		3090	/* irq handler */
170	giacomo	3091
428	giacomo	3092	static char *irq_name[] = { "FMTCHG", "VSYNC", "HSYNC", "OFLOW", "HLOCK",
		3093	"VPRES", "6", "7", "I2CDONE", "GPINT", "10",
		3094	"RISCI", "FBUS", "FTRGT", "FDSR", "PPERR",
		3095	"RIPERR", "PABORT", "OCERR", "SCERR" };
170	giacomo	3096
428	giacomo	3097	static void bttv_print_irqbits(u32 print, u32 mark)
		3098	{
		3099	unsigned int i;
		3100
		3101	printk("bits:");
		3102	for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
		3103	if (print & (1 << i))
		3104	printk(" %s",irq_name[i]);
		3105	if (mark & (1 << i))
		3106	printk("*");
170	giacomo	3107	}
428	giacomo	3108	}
170	giacomo	3109
428	giacomo	3110	static void bttv_print_riscaddr(struct bttv *btv)
		3111	{
		3112	printk(" main: %08Lx\n",
		3113	(unsigned long long)btv->main.dma);
		3114	printk(" vbi : o=%08Lx e=%08Lx\n",
		3115	btv->curr.vbi ? (unsigned long long)btv->curr.vbi->top.dma : 0,
		3116	btv->curr.vbi ? (unsigned long long)btv->curr.vbi->bottom.dma : 0);
		3117	printk(" cap : o=%08Lx e=%08Lx\n",
		3118	btv->curr.top ? (unsigned long long)btv->curr.top->top.dma : 0,
		3119	btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
		3120	printk(" scr : o=%08Lx e=%08Lx\n",
		3121	btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
		3122	btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
		3123	}
170	giacomo	3124
428	giacomo	3125	static int
		3126	bttv_irq_next_set(struct bttv btv, struct bttv_buffer_set set)
		3127	{
		3128	struct bttv_buffer *item;
170	giacomo	3129
428	giacomo	3130	memset(set,0,sizeof(*set));
170	giacomo	3131
428	giacomo	3132	if (!list_empty(&btv->vcapture)) {
		3133	set->irqflags = 1;
		3134	set->vbi = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
		3135	}
170	giacomo	3136
428	giacomo	3137	if (!list_empty(&btv->capture)) {
		3138	set->irqflags = 1;
		3139	item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
		3140	if (V4L2_FIELD_HAS_TOP(item->vb.field))
		3141	set->top = item;
		3142	if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
		3143	set->bottom = item;
170	giacomo	3144
428	giacomo	3145	if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
		3146	(item->vb.queue.next != &btv->capture)) {
		3147	item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
		3148	if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
		3149	if (NULL == set->top &&
		3150	V4L2_FIELD_TOP == item->vb.field) {
		3151	set->top = item;
		3152	}
		3153	if (NULL == set->bottom &&
		3154	V4L2_FIELD_BOTTOM == item->vb.field) {
		3155	set->bottom = item;
		3156	}
		3157	if (NULL != set->top && NULL != set->bottom)
		3158	set->topirq = 2;
		3159	}
		3160	}
		3161	}
170	giacomo	3162
428	giacomo	3163	if (NULL != btv->screen) {
		3164	if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
		3165	if (NULL == set->top && NULL == set->bottom) {
		3166	set->top = btv->screen;
		3167	set->bottom = btv->screen;
		3168	}
		3169	} else {
		3170	if (V4L2_FIELD_TOP == btv->screen->vb.field &&
		3171	NULL == set->top) {
		3172	set->top = btv->screen;
		3173	}
		3174	if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
		3175	NULL == set->bottom) {
		3176	set->bottom = btv->screen;
		3177	}
		3178	}
		3179	}
607	giacomo	3180
		3181	dprintk("bttv%d: next set: top=%x bottom=%x vbi=%x "
		3182	"[screen=%x,irq=%d,%d]\n",
		3183	btv->nr,(int)set->top, (int)set->bottom, (int)set->vbi,
		3184	(int)btv->screen,set->irqflags,set->topirq);
170	giacomo	3185	return 0;
		3186	}
		3187
428	giacomo	3188	static void
		3189	bttv_irq_wakeup_set(struct bttv btv, struct bttv_buffer_set wakeup,
		3190	struct bttv_buffer_set *curr, unsigned int state)
		3191	{
		3192	struct timeval ts;
170	giacomo	3193
516	giacomo	3194	//do_gettimeofday(&ts);
170	giacomo	3195
428	giacomo	3196	if (NULL != wakeup->vbi) {
		3197	wakeup->vbi->vb.ts = ts;
		3198	wakeup->vbi->vb.field_count = btv->field_count;
		3199	wakeup->vbi->vb.state = state;
491	giacomo	3200	//wake_up(&wakeup->vbi->vb.done);
428	giacomo	3201	}
		3202	if (wakeup->top == wakeup->bottom) {
		3203	if (NULL != wakeup->top && curr->top != wakeup->top) {
		3204	if (irq_debug > 1)
607	giacomo	3205	printk("bttv%d: wakeup: both=%x\n",btv->nr,(int)wakeup->top);
428	giacomo	3206	wakeup->top->vb.ts = ts;
		3207	wakeup->top->vb.field_count = btv->field_count;
		3208	wakeup->top->vb.state = state;
491	giacomo	3209	//wake_up(&wakeup->top->vb.done);
428	giacomo	3210	}
		3211	} else {
		3212	if (NULL != wakeup->top && curr->top != wakeup->top) {
		3213	if (irq_debug > 1)
607	giacomo	3214	printk("bttv%d: wakeup: top=%x\n",btv->nr,(int)wakeup->top);
428	giacomo	3215	wakeup->top->vb.ts = ts;
		3216	wakeup->top->vb.field_count = btv->field_count;
		3217	wakeup->top->vb.state = state;
491	giacomo	3218	//wake_up(&wakeup->top->vb.done);
428	giacomo	3219	}
		3220	if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
		3221	if (irq_debug > 1)
607	giacomo	3222	printk("bttv%d: wakeup: bottom=%x\n",btv->nr,(int)wakeup->bottom);
428	giacomo	3223	wakeup->bottom->vb.ts = ts;
		3224	wakeup->bottom->vb.field_count = btv->field_count;
		3225	wakeup->bottom->vb.state = state;
		3226	}
		3227	}
		3228	}
		3229
		3230	static void bttv_irq_timeout(unsigned long data)
170	giacomo	3231	{
428	giacomo	3232	struct bttv btv = (struct bttv )data;
		3233	struct bttv_buffer_set old,new;
		3234	struct bttv_buffer *item;
		3235
		3236	if (bttv_verbose) {
		3237	printk(KERN_INFO "bttv%d: timeout: risc=%08x, ",
		3238	btv->nr,btread(BT848_RISC_COUNT));
		3239	bttv_print_irqbits(btread(BT848_INT_STAT),0);
		3240	printk("\n");
		3241	}
		3242
		3243	spin_lock(&btv->s_lock);
		3244
		3245	/* deactivate stuff */
		3246	memset(&new,0,sizeof(new));
		3247	old = btv->curr;
		3248	btv->curr = new;
		3249	bttv_buffer_set_activate(btv, &new);
		3250	bttv_set_dma(btv, 0, 0);
		3251
		3252	/* wake up */
		3253	bttv_irq_wakeup_set(btv, &old, &new, STATE_ERROR);
		3254
		3255	/* cancel all outstanding capture / vbi requests */
		3256	while (!list_empty(&btv->capture)) {
		3257	item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
		3258	list_del(&item->vb.queue);
		3259	item->vb.state = STATE_ERROR;
491	giacomo	3260	//wake_up(&item->vb.done);
428	giacomo	3261	}
		3262	while (!list_empty(&btv->vcapture)) {
		3263	item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
		3264	list_del(&item->vb.queue);
		3265	item->vb.state = STATE_ERROR;
491	giacomo	3266	//wake_up(&item->vb.done);
428	giacomo	3267	}
		3268
		3269	btv->errors++;
		3270	spin_unlock(&btv->s_lock);
		3271	}
		3272
		3273	static void
		3274	bttv_irq_wakeup_top(struct bttv *btv)
		3275	{
		3276	struct bttv_buffer *wakeup = btv->curr.top;
		3277
		3278	if (NULL == wakeup)
		3279	return;
		3280
		3281	spin_lock(&btv->s_lock);
		3282	btv->curr.topirq = 0;
		3283	btv->curr.top = NULL;
		3284	bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
		3285
516	giacomo	3286	//do_gettimeofday(&wakeup->vb.ts);
428	giacomo	3287	wakeup->vb.field_count = btv->field_count;
		3288	wakeup->vb.state = STATE_DONE;
491	giacomo	3289	//wake_up(&wakeup->vb.done);
428	giacomo	3290	spin_unlock(&btv->s_lock);
		3291	}
		3292
		3293	static void
		3294	bttv_irq_switch_fields(struct bttv *btv)
		3295	{
		3296	struct bttv_buffer_set new;
		3297	struct bttv_buffer_set old;
		3298	dma_addr_t rc;
		3299
		3300	spin_lock(&btv->s_lock);
		3301
		3302	/* new buffer set */
		3303	bttv_irq_next_set(btv, &new);
		3304	rc = btread(BT848_RISC_COUNT);
		3305	if (rc < btv->main.dma \|\| rc > btv->main.dma + 0x100) {
		3306	if (1 /* irq_debug */)
		3307	printk("bttv%d: skipped frame. no signal? high irq latency?\n",
		3308	btv->nr);
		3309	spin_unlock(&btv->s_lock);
		3310	return;
		3311	}
		3312
		3313	/* switch over */
		3314	old = btv->curr;
		3315	btv->curr = new;
		3316	bttv_buffer_set_activate(btv, &new);
		3317	bttv_set_dma(btv, 0, new.irqflags);
		3318
		3319	/* switch input */
		3320	if (UNSET != btv->new_input) {
516	giacomo	3321	//video_mux(btv,btv->new_input);
428	giacomo	3322	btv->new_input = UNSET;
		3323	}
		3324
		3325	/* wake up finished buffers */
		3326	bttv_irq_wakeup_set(btv, &old, &new, STATE_DONE);
		3327	spin_unlock(&btv->s_lock);
		3328	}
		3329
752	giacomo	3330	extern int task_activate(int pid);
		3331
428	giacomo	3332	static irqreturn_t bttv_irq(int irq, void dev_id, struct pt_regs regs)
		3333	{
170	giacomo	3334	u32 stat,astat;
		3335	u32 dstat;
		3336	int count;
428	giacomo	3337	struct bttv *btv;
		3338	int handled = 0;
170	giacomo	3339
428	giacomo	3340	btv=(struct bttv *)dev_id;
170	giacomo	3341	count=0;
428	giacomo	3342	while (1) {
701	giacomo	3343
170	giacomo	3344	/* get/clear interrupt status bits */
		3345	stat=btread(BT848_INT_STAT);
		3346	astat=stat&btread(BT848_INT_MASK);
428	giacomo	3347	if (!astat)
		3348	break;
		3349	handled = 1;
170	giacomo	3350	btwrite(stat,BT848_INT_STAT);
		3351
		3352	/* get device status bits */
		3353	dstat=btread(BT848_DSTATUS);
		3354
		3355	if (irq_debug) {
428	giacomo	3356	printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
		3357	"riscs=%x, riscc=%08x, ",
		3358	btv->nr, count, btv->field_count,
		3359	stat>>28, btread(BT848_RISC_COUNT));
		3360	bttv_print_irqbits(stat,astat);
170	giacomo	3361	if (stat & BT848_INT_HLOCK)
428	giacomo	3362	printk(" HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
170	giacomo	3363	? "yes" : "no");
		3364	if (stat & BT848_INT_VPRES)
428	giacomo	3365	printk(" PRES => %s", (dstat & BT848_DSTATUS_PRES)
170	giacomo	3366	? "yes" : "no");
		3367	if (stat & BT848_INT_FMTCHG)
428	giacomo	3368	printk(" NUML => %s", (dstat & BT848_DSTATUS_NUML)
170	giacomo	3369	? "625" : "525");
428	giacomo	3370	printk("\n");
170	giacomo	3371	}
		3372
696	giacomo	3373	if (astat&BT848_INT_VSYNC)
428	giacomo	3374	btv->field_count++;
170	giacomo	3375
428	giacomo	3376	if (astat & BT848_INT_GPINT) {
		3377	#ifdef CONFIG_VIDEO_IR
		3378	if (btv->remote)
		3379	bttv_input_irq(btv);
		3380	#endif
491	giacomo	3381	//wake_up(&btv->gpioq);
170	giacomo	3382	}
		3383
428	giacomo	3384	if ((astat & BT848_INT_RISCI) && (stat & (2<<28)))
		3385	bttv_irq_wakeup_top(btv);
170	giacomo	3386
696	giacomo	3387	if ((astat & BT848_INT_RISCI) && (stat & (1<<28))) {
752	giacomo	3388	/* S.Ha.R.K. task activate */
		3389	task_activate(grab_task);
428	giacomo	3390	bttv_irq_switch_fields(btv);
696	giacomo	3391	}
428	giacomo	3392
		3393	if ((astat & BT848_INT_HLOCK) && btv->opt_automute)
		3394	audio_mux(btv, -1);
		3395
		3396	if (astat & (BT848_INT_SCERR\|BT848_INT_OCERR)) {
		3397	printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->nr,
		3398	(astat & BT848_INT_SCERR) ? "SCERR" : "",
		3399	(astat & BT848_INT_OCERR) ? "OCERR" : "",
		3400	btread(BT848_RISC_COUNT));
		3401	bttv_print_irqbits(stat,astat);
		3402	printk("\n");
		3403	if (bttv_debug)
		3404	bttv_print_riscaddr(btv);
170	giacomo	3405	}
428	giacomo	3406	if (fdsr && astat & BT848_INT_FDSR) {
		3407	printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
		3408	btv->nr,btread(BT848_RISC_COUNT));
		3409	if (bttv_debug)
		3410	bttv_print_riscaddr(btv);
		3411	}
170	giacomo	3412
		3413	count++;
428	giacomo	3414	if (count > 4) {
170	giacomo	3415	btwrite(0, BT848_INT_MASK);
428	giacomo	3416	printk(KERN_ERR
		3417	"bttv%d: IRQ lockup, cleared int mask [", btv->nr);
		3418	bttv_print_irqbits(stat,astat);
		3419	printk("]\n");
170	giacomo	3420	}
		3421	}
428	giacomo	3422	return IRQ_RETVAL(handled);
		3423	}
170	giacomo	3424
257	giacomo	3425
428	giacomo	3426	/* ----------------------------------------------------------------------- */
		3427	/* initialitation */
541	giacomo	3428
428	giacomo	3429	static struct video_device vdev_init(struct bttv btv,
		3430	struct video_device *template,
		3431	char *type)
		3432	{
		3433	struct video_device *vfd;
		3434
		3435	vfd = video_device_alloc();
		3436	if (NULL == vfd)
		3437	return NULL;
		3438	vfd = template;
		3439	vfd->minor = -1;
		3440	vfd->dev = &btv->dev->dev;
		3441	vfd->release = video_device_release;
463	giacomo	3442	snprintf26(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
428	giacomo	3443	btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
		3444	type, bttv_tvcards[btv->type].name);
		3445	return vfd;
		3446	}
		3447
541	giacomo	3448	void bttv_unregister_video(struct bttv *btv)
428	giacomo	3449	{
		3450	if (btv->video_dev) {
		3451	if (-1 != btv->video_dev->minor)
		3452	video_unregister_device(btv->video_dev);
		3453	else
		3454	video_device_release(btv->video_dev);
		3455	btv->video_dev = NULL;
		3456	}
541	giacomo	3457	/*
428	giacomo	3458	if (btv->vbi_dev) {
		3459	if (-1 != btv->vbi_dev->minor)
		3460	video_unregister_device(btv->vbi_dev);
		3461	else
		3462	video_device_release(btv->vbi_dev);
		3463	btv->vbi_dev = NULL;
		3464	}
541	giacomo	3465	*/
428	giacomo	3466	if (btv->radio_dev) {
		3467	if (-1 != btv->radio_dev->minor)
		3468	video_unregister_device(btv->radio_dev);
		3469	else
		3470	video_device_release(btv->radio_dev);
		3471	btv->radio_dev = NULL;
		3472	}
		3473	}
541	giacomo	3474
428	giacomo	3475	/* register video4linux devices */
541	giacomo	3476
		3477	int __devinit bttv_register_video(struct bttv *btv)
428	giacomo	3478	{
		3479	btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
		3480	if (NULL == btv->video_dev)
		3481	goto err;
		3482	if (video_register_device(btv->video_dev,VFL_TYPE_GRABBER,video_nr)<0)
		3483	goto err;
		3484	printk(KERN_INFO "bttv%d: registered device video%d\n",
		3485	btv->nr,btv->video_dev->minor & 0x1f);
541	giacomo	3486	/*
428	giacomo	3487	video_device_create_file(btv->video_dev, &class_device_attr_card);
		3488	btv->vbi_dev = vdev_init(btv, &bttv_vbi_template, "vbi");
		3489	if (NULL == btv->vbi_dev)
		3490	goto err;
		3491	if (video_register_device(btv->vbi_dev,VFL_TYPE_VBI,vbi_nr)<0)
		3492	goto err;
		3493	printk(KERN_INFO "bttv%d: registered device vbi%d\n",
		3494	btv->nr,btv->vbi_dev->minor & 0x1f);
541	giacomo	3495	*/
428	giacomo	3496	if (!btv->has_radio)
		3497	return 0;
		3498	btv->radio_dev = vdev_init(btv, &radio_template, "radio");
		3499	if (NULL == btv->radio_dev)
		3500	goto err;
		3501	if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,radio_nr)<0)
		3502	goto err;
		3503	printk(KERN_INFO "bttv%d: registered device radio%d\n",
		3504	btv->nr,btv->radio_dev->minor & 0x1f);
		3505
		3506	return 0;
		3507
		3508	err:
		3509	bttv_unregister_video(btv);
		3510	return -1;
		3511	}
		3512
		3513	/* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
		3514	/* response on cards with no firmware is not enabled by OF */
		3515	static void pci_set_command(struct pci_dev *dev)
		3516	{
		3517	#if defined(__powerpc__)
		3518	unsigned int cmd;
170	giacomo	3519
428	giacomo	3520	pci_read_config_dword(dev, PCI_COMMAND, &cmd);
		3521	cmd = (cmd \| PCI_COMMAND_MEMORY );
		3522	pci_write_config_dword(dev, PCI_COMMAND, cmd);
		3523	#endif
170	giacomo	3524	}
		3525
428	giacomo	3526	static int __devinit bttv_probe(struct pci_dev *dev,
		3527	const struct pci_device_id *pci_id)
170	giacomo	3528	{
428	giacomo	3529	int result;
170	giacomo	3530	unsigned char lat;
428	giacomo	3531	struct bttv *btv;
		3532
170	giacomo	3533	if (bttv_num == BTTV_MAX)
		3534	return -ENOMEM;
		3535	printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
428	giacomo	3536	btv=&bttvs[bttv_num];
		3537	memset(btv,0,sizeof(*btv));
		3538	btv->nr = bttv_num;
463	giacomo	3539	sprintf26(btv->name,"bttv%d",btv->nr);
170	giacomo	3540
428	giacomo	3541	/* initialize structs / fill in defaults */
516	giacomo	3542	//init_MUTEX(&btv->lock);
		3543	//init_MUTEX(&btv->reslock);
428	giacomo	3544	btv->s_lock = SPIN_LOCK_UNLOCKED;
491	giacomo	3545	//init_waitqueue_head(&btv->gpioq);
428	giacomo	3546	INIT_LIST_HEAD(&btv->capture);
		3547	INIT_LIST_HEAD(&btv->vcapture);
		3548	#ifdef VIDIOC_G_PRIORITY
		3549	v4l2_prio_init(&btv->prio);
		3550	#endif
274	giacomo	3551
428	giacomo	3552	init_timer(&btv->timeout);
		3553	btv->timeout.function = bttv_irq_timeout;
		3554	btv->timeout.data = (unsigned long)btv;
		3555
		3556	btv->i2c_rc = -1;
		3557	btv->tuner_type = UNSET;
		3558	btv->pinnacle_id = UNSET;
		3559	btv->new_input = UNSET;
		3560	btv->has_radio=radio[btv->nr];
		3561
		3562	/* pci stuff (init, get irq/mmio, ... */
		3563	btv->dev = dev;
		3564	btv->id = dev->device;
537	giacomo	3565
428	giacomo	3566	if (pci_enable_device(dev)) {
		3567	printk(KERN_WARNING "bttv%d: Can't enable device.\n",
		3568	btv->nr);
		3569	return -EIO;
		3570	}
537	giacomo	3571
428	giacomo	3572	if (pci_set_dma_mask(dev, 0xffffffff)) {
		3573	printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
		3574	btv->nr);
		3575	return -EIO;
		3576	}
		3577	if (!request_mem_region(pci_resource_start(dev,0),
		3578	pci_resource_len(dev,0),
		3579	btv->name)) {
		3580	printk(KERN_WARNING "bttv%d: can't request iomem (0x%lx).\n",
		3581	btv->nr, pci_resource_start(dev,0));
		3582	return -EBUSY;
		3583	}
537	giacomo	3584
428	giacomo	3585	pci_set_master(dev);
		3586	pci_set_command(dev);
		3587	pci_set_drvdata(dev,btv);
		3588	if (!pci_dma_supported(dev,0xffffffff)) {
		3589	printk("bttv%d: Oops: no 32bit PCI DMA ???\n", btv->nr);
		3590	result = -EIO;
		3591	goto fail1;
		3592	}
170	giacomo	3593
428	giacomo	3594	pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
		3595	pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
		3596	printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
		3597	bttv_num,btv->id, btv->revision, pci_name(dev));
		3598	printk("irq: %d, latency: %d, mmio: 0x%lx\n",
		3599	btv->dev->irq, lat, pci_resource_start(dev,0));
537	giacomo	3600
		3601	udelay(1000);
		3602
428	giacomo	3603	btv->bt848_mmio=ioremap(pci_resource_start(dev,0), 0x1000);
		3604	if (NULL == ioremap(pci_resource_start(dev,0), 0x1000)) {
		3605	printk("bttv%d: ioremap() failed\n", btv->nr);
		3606	result = -EIO;
		3607	goto fail1;
170	giacomo	3608	}
		3609
428	giacomo	3610	/* identify card */
170	giacomo	3611	bttv_idcard(btv);
		3612
428	giacomo	3613	/* disable irqs, register irq handler */
170	giacomo	3614	btwrite(0, BT848_INT_MASK);
428	giacomo	3615	result = request_irq(btv->dev->irq, bttv_irq,
		3616	SA_SHIRQ \| SA_INTERRUPT,btv->name,(void *)btv);
		3617	if (result < 0) {
		3618	printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
		3619	bttv_num,btv->dev->irq);
		3620	goto fail1;
		3621	}
170	giacomo	3622
428	giacomo	3623	if (0 != bttv_handle_chipset(btv)) {
		3624	result = -EIO;
		3625	goto fail2;
		3626	}
		3627
		3628	/* init options from insmod args */
		3629	btv->opt_combfilter = combfilter;
		3630	btv->opt_lumafilter = lumafilter;
		3631	btv->opt_automute = automute;
		3632	btv->opt_chroma_agc = chroma_agc;
		3633	btv->opt_adc_crush = adc_crush;
		3634	btv->opt_vcr_hack = vcr_hack;
170	giacomo	3635
428	giacomo	3636	/* fill struct bttv with some useful defaults */
		3637	btv->init.btv = btv;
		3638	btv->init.ov.w.width = 320;
		3639	btv->init.ov.w.height = 240;
		3640	btv->init.fmt = format_by_palette(VIDEO_PALETTE_RGB24);
		3641	btv->init.width = 320;
		3642	btv->init.height = 240;
		3643	btv->init.lines = 16;
		3644	btv->input = 0;
		3645
		3646	/* initialize hardware */
		3647	if (bttv_gpio)
		3648	bttv_gpio_tracking(btv,"pre-init");
		3649
		3650	bttv_risc_init_main(btv);
		3651	if (!bttv_tvcards[btv->type].no_video)
		3652	init_bt848(btv);
		3653
		3654	/* gpio */
		3655	btwrite(0x00, BT848_GPIO_REG_INP);
		3656	btwrite(0x00, BT848_GPIO_OUT_EN);
		3657	if (bttv_gpio)
		3658	bttv_gpio_tracking(btv,"init");
		3659
		3660	/* needs to be done before i2c is registered */
		3661	bttv_init_card1(btv);
		3662
		3663	/* register i2c */
		3664	init_bttv_i2c(btv);
		3665
		3666	/* some card-specific stuff (needs working i2c) */
		3667	bttv_init_card2(btv);
		3668
		3669	/* register video4linux + input */
		3670	if (!bttv_tvcards[btv->type].no_video) {
541	giacomo	3671	bttv_register_video(btv);
428	giacomo	3672	#ifdef CONFIG_VIDEO_IR
		3673	bttv_input_init(btv);
		3674	#endif
		3675
		3676	bt848_bright(btv,32768);
		3677	bt848_contrast(btv,32768);
		3678	bt848_hue(btv,32768);
		3679	bt848_sat(btv,32768);
		3680	audio_mux(btv,AUDIO_MUTE);
		3681	set_input(btv,0);
		3682	}
		3683
		3684	/* everything is fine */
170	giacomo	3685	bttv_num++;
		3686	return 0;
		3687
428	giacomo	3688	fail2:
		3689	free_irq(btv->dev->irq,btv);
		3690
		3691	fail1:
		3692	if (btv->bt848_mmio)
		3693	iounmap(btv->bt848_mmio);
		3694	release_mem_region(pci_resource_start(btv->dev,0),
		3695	pci_resource_len(btv->dev,0));
		3696	pci_set_drvdata(dev,NULL);
		3697	return result;
170	giacomo	3698	}
		3699
428	giacomo	3700	static void __devexit bttv_remove(struct pci_dev *pci_dev)
170	giacomo	3701	{
428	giacomo	3702	struct bttv *btv = pci_get_drvdata(pci_dev);
170	giacomo	3703
428	giacomo	3704	if (bttv_verbose)
		3705	printk("bttv%d: unloading\n",btv->nr);
170	giacomo	3706
428	giacomo	3707	/* shutdown everything (DMA+IRQs) */
		3708	btand(~15, BT848_GPIO_DMA_CTL);
		3709	btwrite(0, BT848_INT_MASK);
		3710	btwrite(~0x0, BT848_INT_STAT);
		3711	btwrite(0x0, BT848_GPIO_OUT_EN);
		3712	if (bttv_gpio)
		3713	bttv_gpio_tracking(btv,"cleanup");
170	giacomo	3714
428	giacomo	3715	/* tell gpio modules we are leaving ... */
		3716	btv->shutdown=1;
491	giacomo	3717	//wake_up(&btv->gpioq);
428	giacomo	3718
		3719	/* unregister i2c_bus + input */
		3720	fini_bttv_i2c(btv);
		3721	#ifdef CONFIG_VIDEO_IR
		3722	bttv_input_fini(btv);
		3723	#endif
		3724
		3725	/* unregister video4linux */
516	giacomo	3726	//bttv_unregister_video(btv);
428	giacomo	3727
		3728	/* free allocated memory */
		3729	btcx_riscmem_free(btv->dev,&btv->main);
		3730
		3731	/* free ressources */
		3732	free_irq(btv->dev->irq,btv);
		3733	iounmap(btv->bt848_mmio);
		3734	release_mem_region(pci_resource_start(btv->dev,0),
		3735	pci_resource_len(btv->dev,0));
		3736
		3737	pci_set_drvdata(pci_dev, NULL);
		3738	return;
		3739	}
		3740
		3741	static struct pci_device_id bttv_pci_tbl[] = {
		3742	{PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
		3743	PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
		3744	{PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
		3745	PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
		3746	{PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
		3747	PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
		3748	{PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
		3749	PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
		3750	{0,}
		3751	};
		3752
		3753	MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
		3754
		3755	static struct pci_driver bttv_pci_driver = {
		3756	.name = "bttv",
		3757	.id_table = bttv_pci_tbl,
		3758	.probe = bttv_probe,
		3759	.remove = __devexit_p(bttv_remove),
		3760	};
		3761
463	giacomo	3762	int bttv_init_module(void)
428	giacomo	3763	{
		3764	int rc;
170	giacomo	3765	bttv_num = 0;
		3766
428	giacomo	3767	printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
		3768	(BTTV_VERSION_CODE >> 16) & 0xff,
		3769	(BTTV_VERSION_CODE >> 8) & 0xff,
		3770	BTTV_VERSION_CODE & 0xff);
		3771	if (gbuffers < 2 \|\| gbuffers > VIDEO_MAX_FRAME)
170	giacomo	3772	gbuffers = 2;
		3773	if (gbufsize < 0 \|\| gbufsize > BTTV_MAX_FBUF)
		3774	gbufsize = BTTV_MAX_FBUF;
428	giacomo	3775	gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
170	giacomo	3776	if (bttv_verbose)
428	giacomo	3777	printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
		3778	gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
170	giacomo	3779
428	giacomo	3780	bttv_check_chipset();
170	giacomo	3781
428	giacomo	3782	rc = pci_module_init(&bttv_pci_driver);
		3783	if (-ENODEV == rc) {
		3784	/* plenty of people trying to use bttv for the cx2388x ... */
		3785	if (NULL != pci_find_device(0x14f1, 0x8800, NULL))
		3786	printk("bttv doesn't support your Conexant 2388x card.\n");
		3787	}
		3788	return rc;
		3789	}
170	giacomo	3790
618	giacomo	3791	void bttv_cleanup_module(void)
428	giacomo	3792	{
		3793	pci_unregister_driver(&bttv_pci_driver);
		3794	return;
		3795	}
195	giacomo	3796
428	giacomo	3797	module_init(bttv_init_module);
		3798	module_exit(bttv_cleanup_module);
195	giacomo	3799
428	giacomo	3800	/*
		3801	* Local variables:
		3802	* c-basic-offset: 8
		3803	* End:
		3804	*/

Subversion Repositories shark

(root)/shark/trunk/drivers/bttv/bttv-driver.c - Rev 752