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

Subversion Repositories shark

(root)/shark/trunk/drivers/bttv/bttv-driver.c @ 623 - Rev 758