1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 
4     bttv - Bt848 frame grabber driver
5 
6     Copyright (C) 1996,97,98 Ralph  Metzler <rjkm@thp.uni-koeln.de>
7 			   & Marcus Metzler <mocm@thp.uni-koeln.de>
8     (c) 1999-2002 Gerd Knorr <kraxel@bytesex.org>
9 
10     some v4l2 code lines are taken from Justin's bttv2 driver which is
11     (c) 2000 Justin Schoeman <justin@suntiger.ee.up.ac.za>
12 
13     V4L1 removal from:
14     (c) 2005-2006 Nickolay V. Shmyrev <nshmyrev@yandex.ru>
15 
16     Fixes to be fully V4L2 compliant by
17     (c) 2006 Mauro Carvalho Chehab <mchehab@kernel.org>
18 
19     Cropping and overscan support
20     Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
21     Sponsored by OPQ Systems AB
22 
23 */
24 
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26 
27 #include <linux/init.h>
28 #include <linux/module.h>
29 #include <linux/delay.h>
30 #include <linux/slab.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>
37 #include "bttvp.h"
38 #include <media/v4l2-common.h>
39 #include <media/v4l2-ioctl.h>
40 #include <media/v4l2-event.h>
41 #include <media/i2c/tvaudio.h>
42 #include <media/drv-intf/msp3400.h>
43 
44 #include <linux/dma-mapping.h>
45 
46 #include <asm/io.h>
47 #include <asm/byteorder.h>
48 
49 #include <media/i2c/saa6588.h>
50 
51 #define BTTV_VERSION "0.9.19"
52 
53 unsigned int bttv_num;			/* number of Bt848s in use */
54 struct bttv *bttvs[BTTV_MAX];
55 
56 unsigned int bttv_debug;
57 unsigned int bttv_verbose = 1;
58 unsigned int bttv_gpio;
59 
60 /* config variables */
61 #ifdef __BIG_ENDIAN
62 static unsigned int bigendian=1;
63 #else
64 static unsigned int bigendian;
65 #endif
66 static unsigned int radio[BTTV_MAX];
67 static unsigned int irq_debug;
68 static unsigned int gbuffers = 8;
69 static unsigned int gbufsize = 0x208000;
70 static unsigned int reset_crop = 1;
71 
72 static int video_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
73 static int radio_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
74 static int vbi_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
75 static int debug_latency;
76 static int disable_ir;
77 
78 static unsigned int fdsr;
79 
80 /* options */
81 static unsigned int combfilter;
82 static unsigned int lumafilter;
83 static unsigned int automute    = 1;
84 static unsigned int chroma_agc;
85 static unsigned int agc_crush   = 1;
86 static unsigned int whitecrush_upper = 0xCF;
87 static unsigned int whitecrush_lower = 0x7F;
88 static unsigned int vcr_hack;
89 static unsigned int irq_iswitch;
90 static unsigned int uv_ratio    = 50;
91 static unsigned int full_luma_range;
92 static unsigned int coring;
93 
94 /* API features (turn on/off stuff for testing) */
95 static unsigned int v4l2        = 1;
96 
97 /* insmod args */
98 module_param(bttv_verbose,      int, 0644);
99 module_param(bttv_gpio,         int, 0644);
100 module_param(bttv_debug,        int, 0644);
101 module_param(irq_debug,         int, 0644);
102 module_param(debug_latency,     int, 0644);
103 module_param(disable_ir,        int, 0444);
104 
105 module_param(fdsr,              int, 0444);
106 module_param(gbuffers,          int, 0444);
107 module_param(gbufsize,          int, 0444);
108 module_param(reset_crop,        int, 0444);
109 
110 module_param(v4l2,              int, 0644);
111 module_param(bigendian,         int, 0644);
112 module_param(irq_iswitch,       int, 0644);
113 module_param(combfilter,        int, 0444);
114 module_param(lumafilter,        int, 0444);
115 module_param(automute,          int, 0444);
116 module_param(chroma_agc,        int, 0444);
117 module_param(agc_crush,         int, 0444);
118 module_param(whitecrush_upper,  int, 0444);
119 module_param(whitecrush_lower,  int, 0444);
120 module_param(vcr_hack,          int, 0444);
121 module_param(uv_ratio,          int, 0444);
122 module_param(full_luma_range,   int, 0444);
123 module_param(coring,            int, 0444);
124 
125 module_param_array(radio,       int, NULL, 0444);
126 module_param_array(video_nr,    int, NULL, 0444);
127 module_param_array(radio_nr,    int, NULL, 0444);
128 module_param_array(vbi_nr,      int, NULL, 0444);
129 
130 MODULE_PARM_DESC(radio, "The TV card supports radio, default is 0 (no)");
131 MODULE_PARM_DESC(bigendian, "byte order of the framebuffer, default is native endian");
132 MODULE_PARM_DESC(bttv_verbose, "verbose startup messages, default is 1 (yes)");
133 MODULE_PARM_DESC(bttv_gpio, "log gpio changes, default is 0 (no)");
134 MODULE_PARM_DESC(bttv_debug, "debug messages, default is 0 (no)");
135 MODULE_PARM_DESC(irq_debug, "irq handler debug messages, default is 0 (no)");
136 MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
137 MODULE_PARM_DESC(gbuffers, "number of capture buffers. range 2-32, default 8");
138 MODULE_PARM_DESC(gbufsize, "size of the capture buffers, default is 0x208000");
139 MODULE_PARM_DESC(reset_crop, "reset cropping parameters at open(), default is 1 (yes) for compatibility with older applications");
140 MODULE_PARM_DESC(automute, "mute audio on bad/missing video signal, default is 1 (yes)");
141 MODULE_PARM_DESC(chroma_agc, "enables the AGC of chroma signal, default is 0 (no)");
142 MODULE_PARM_DESC(agc_crush, "enables the luminance AGC crush, default is 1 (yes)");
143 MODULE_PARM_DESC(whitecrush_upper, "sets the white crush upper value, default is 207");
144 MODULE_PARM_DESC(whitecrush_lower, "sets the white crush lower value, default is 127");
145 MODULE_PARM_DESC(vcr_hack, "enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
146 MODULE_PARM_DESC(irq_iswitch, "switch inputs in irq handler");
147 MODULE_PARM_DESC(uv_ratio, "ratio between u and v gains, default is 50");
148 MODULE_PARM_DESC(full_luma_range, "use the full luma range, default is 0 (no)");
149 MODULE_PARM_DESC(coring, "set the luma coring level, default is 0 (no)");
150 MODULE_PARM_DESC(video_nr, "video device numbers");
151 MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
152 MODULE_PARM_DESC(radio_nr, "radio device numbers");
153 
154 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
155 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
156 MODULE_LICENSE("GPL");
157 MODULE_VERSION(BTTV_VERSION);
158 
159 #define V4L2_CID_PRIVATE_COMBFILTER		(V4L2_CID_USER_BTTV_BASE + 0)
160 #define V4L2_CID_PRIVATE_AUTOMUTE		(V4L2_CID_USER_BTTV_BASE + 1)
161 #define V4L2_CID_PRIVATE_LUMAFILTER		(V4L2_CID_USER_BTTV_BASE + 2)
162 #define V4L2_CID_PRIVATE_AGC_CRUSH		(V4L2_CID_USER_BTTV_BASE + 3)
163 #define V4L2_CID_PRIVATE_VCR_HACK		(V4L2_CID_USER_BTTV_BASE + 4)
164 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER	(V4L2_CID_USER_BTTV_BASE + 5)
165 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER	(V4L2_CID_USER_BTTV_BASE + 6)
166 #define V4L2_CID_PRIVATE_UV_RATIO		(V4L2_CID_USER_BTTV_BASE + 7)
167 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE	(V4L2_CID_USER_BTTV_BASE + 8)
168 #define V4L2_CID_PRIVATE_CORING			(V4L2_CID_USER_BTTV_BASE + 9)
169 
170 /* ----------------------------------------------------------------------- */
171 /* sysfs                                                                   */
172 
173 static ssize_t show_card(struct device *cd,
174 			 struct device_attribute *attr, char *buf)
175 {
176 	struct video_device *vfd = to_video_device(cd);
177 	struct bttv *btv = video_get_drvdata(vfd);
178 	return sprintf(buf, "%d\n", btv ? btv->c.type : UNSET);
179 }
180 static DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
181 
182 /* ----------------------------------------------------------------------- */
183 /* dvb auto-load setup                                                     */
184 #if defined(CONFIG_MODULES) && defined(MODULE)
185 static void request_module_async(struct work_struct *work)
186 {
187 	request_module("dvb-bt8xx");
188 }
189 
190 static void request_modules(struct bttv *dev)
191 {
192 	INIT_WORK(&dev->request_module_wk, request_module_async);
193 	schedule_work(&dev->request_module_wk);
194 }
195 
196 static void flush_request_modules(struct bttv *dev)
197 {
198 	flush_work(&dev->request_module_wk);
199 }
200 #else
201 #define request_modules(dev)
202 #define flush_request_modules(dev) do {} while(0)
203 #endif /* CONFIG_MODULES */
204 
205 
206 /* ----------------------------------------------------------------------- */
207 /* static data                                                             */
208 
209 /* special timing tables from conexant... */
210 static u8 SRAM_Table[][60] =
211 {
212 	/* PAL digital input over GPIO[7:0] */
213 	{
214 		45, // 45 bytes following
215 		0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
216 		0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
217 		0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
218 		0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
219 		0x37,0x00,0xAF,0x21,0x00
220 	},
221 	/* NTSC digital input over GPIO[7:0] */
222 	{
223 		51, // 51 bytes following
224 		0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
225 		0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
226 		0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
227 		0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
228 		0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
229 		0x00,
230 	},
231 	// TGB_NTSC392 // quartzsight
232 	// This table has been modified to be used for Fusion Rev D
233 	{
234 		0x2A, // size of table = 42
235 		0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
236 		0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
237 		0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
238 		0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
239 		0x20, 0x00
240 	}
241 };
242 
243 /* minhdelayx1	first video pixel we can capture on a line and
244    hdelayx1	start of active video, both relative to rising edge of
245 		/HRESET pulse (0H) in 1 / fCLKx1.
246    swidth	width of active video and
247    totalwidth	total line width, both in 1 / fCLKx1.
248    sqwidth	total line width in square pixels.
249    vdelay	start of active video in 2 * field lines relative to
250 		trailing edge of /VRESET pulse (VDELAY register).
251    sheight	height of active video in 2 * field lines.
252    extraheight	Added to sheight for cropcap.bounds.height only
253    videostart0	ITU-R frame line number of the line corresponding
254 		to vdelay in the first field. */
255 #define CROPCAP(minhdelayx1, hdelayx1, swidth, totalwidth, sqwidth,	 \
256 		vdelay, sheight, extraheight, videostart0)		 \
257 	.cropcap.bounds.left = minhdelayx1,				 \
258 	/* * 2 because vertically we count field lines times two, */	 \
259 	/* e.g. 23 * 2 to 23 * 2 + 576 in PAL-BGHI defrect. */		 \
260 	.cropcap.bounds.top = (videostart0) * 2 - (vdelay) + MIN_VDELAY, \
261 	/* 4 is a safety margin at the end of the line. */		 \
262 	.cropcap.bounds.width = (totalwidth) - (minhdelayx1) - 4,	 \
263 	.cropcap.bounds.height = (sheight) + (extraheight) + (vdelay) -	 \
264 				 MIN_VDELAY,				 \
265 	.cropcap.defrect.left = hdelayx1,				 \
266 	.cropcap.defrect.top = (videostart0) * 2,			 \
267 	.cropcap.defrect.width = swidth,				 \
268 	.cropcap.defrect.height = sheight,				 \
269 	.cropcap.pixelaspect.numerator = totalwidth,			 \
270 	.cropcap.pixelaspect.denominator = sqwidth,
271 
272 const struct bttv_tvnorm bttv_tvnorms[] = {
273 	/* PAL-BDGHI */
274 	/* max. active video is actually 922, but 924 is divisible by 4 and 3! */
275 	/* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
276 	{
277 		.v4l2_id        = V4L2_STD_PAL,
278 		.name           = "PAL",
279 		.Fsc            = 35468950,
280 		.swidth         = 924,
281 		.sheight        = 576,
282 		.totalwidth     = 1135,
283 		.adelay         = 0x7f,
284 		.bdelay         = 0x72,
285 		.iform          = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
286 		.scaledtwidth   = 1135,
287 		.hdelayx1       = 186,
288 		.hactivex1      = 924,
289 		.vdelay         = 0x20,
290 		.vbipack        = 255, /* min (2048 / 4, 0x1ff) & 0xff */
291 		.sram           = 0,
292 		/* ITU-R frame line number of the first VBI line
293 		   we can capture, of the first and second field.
294 		   The last line is determined by cropcap.bounds. */
295 		.vbistart       = { 7, 320 },
296 		CROPCAP(/* minhdelayx1 */ 68,
297 			/* hdelayx1 */ 186,
298 			/* Should be (768 * 1135 + 944 / 2) / 944.
299 			   cropcap.defrect is used for image width
300 			   checks, so we keep the old value 924. */
301 			/* swidth */ 924,
302 			/* totalwidth */ 1135,
303 			/* sqwidth */ 944,
304 			/* vdelay */ 0x20,
305 			/* sheight */ 576,
306 			/* bt878 (and bt848?) can capture another
307 			   line below active video. */
308 			/* extraheight */ 2,
309 			/* videostart0 */ 23)
310 	},{
311 		.v4l2_id        = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
312 		.name           = "NTSC",
313 		.Fsc            = 28636363,
314 		.swidth         = 768,
315 		.sheight        = 480,
316 		.totalwidth     = 910,
317 		.adelay         = 0x68,
318 		.bdelay         = 0x5d,
319 		.iform          = (BT848_IFORM_NTSC|BT848_IFORM_XT0),
320 		.scaledtwidth   = 910,
321 		.hdelayx1       = 128,
322 		.hactivex1      = 910,
323 		.vdelay         = 0x1a,
324 		.vbipack        = 144, /* min (1600 / 4, 0x1ff) & 0xff */
325 		.sram           = 1,
326 		.vbistart	= { 10, 273 },
327 		CROPCAP(/* minhdelayx1 */ 68,
328 			/* hdelayx1 */ 128,
329 			/* Should be (640 * 910 + 780 / 2) / 780? */
330 			/* swidth */ 768,
331 			/* totalwidth */ 910,
332 			/* sqwidth */ 780,
333 			/* vdelay */ 0x1a,
334 			/* sheight */ 480,
335 			/* extraheight */ 0,
336 			/* videostart0 */ 23)
337 	},{
338 		.v4l2_id        = V4L2_STD_SECAM,
339 		.name           = "SECAM",
340 		.Fsc            = 35468950,
341 		.swidth         = 924,
342 		.sheight        = 576,
343 		.totalwidth     = 1135,
344 		.adelay         = 0x7f,
345 		.bdelay         = 0xb0,
346 		.iform          = (BT848_IFORM_SECAM|BT848_IFORM_XT1),
347 		.scaledtwidth   = 1135,
348 		.hdelayx1       = 186,
349 		.hactivex1      = 922,
350 		.vdelay         = 0x20,
351 		.vbipack        = 255,
352 		.sram           = 0, /* like PAL, correct? */
353 		.vbistart	= { 7, 320 },
354 		CROPCAP(/* minhdelayx1 */ 68,
355 			/* hdelayx1 */ 186,
356 			/* swidth */ 924,
357 			/* totalwidth */ 1135,
358 			/* sqwidth */ 944,
359 			/* vdelay */ 0x20,
360 			/* sheight */ 576,
361 			/* extraheight */ 0,
362 			/* videostart0 */ 23)
363 	},{
364 		.v4l2_id        = V4L2_STD_PAL_Nc,
365 		.name           = "PAL-Nc",
366 		.Fsc            = 28636363,
367 		.swidth         = 640,
368 		.sheight        = 576,
369 		.totalwidth     = 910,
370 		.adelay         = 0x68,
371 		.bdelay         = 0x5d,
372 		.iform          = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
373 		.scaledtwidth   = 780,
374 		.hdelayx1       = 130,
375 		.hactivex1      = 734,
376 		.vdelay         = 0x1a,
377 		.vbipack        = 144,
378 		.sram           = -1,
379 		.vbistart	= { 7, 320 },
380 		CROPCAP(/* minhdelayx1 */ 68,
381 			/* hdelayx1 */ 130,
382 			/* swidth */ (640 * 910 + 780 / 2) / 780,
383 			/* totalwidth */ 910,
384 			/* sqwidth */ 780,
385 			/* vdelay */ 0x1a,
386 			/* sheight */ 576,
387 			/* extraheight */ 0,
388 			/* videostart0 */ 23)
389 	},{
390 		.v4l2_id        = V4L2_STD_PAL_M,
391 		.name           = "PAL-M",
392 		.Fsc            = 28636363,
393 		.swidth         = 640,
394 		.sheight        = 480,
395 		.totalwidth     = 910,
396 		.adelay         = 0x68,
397 		.bdelay         = 0x5d,
398 		.iform          = (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
399 		.scaledtwidth   = 780,
400 		.hdelayx1       = 135,
401 		.hactivex1      = 754,
402 		.vdelay         = 0x1a,
403 		.vbipack        = 144,
404 		.sram           = -1,
405 		.vbistart	= { 10, 273 },
406 		CROPCAP(/* minhdelayx1 */ 68,
407 			/* hdelayx1 */ 135,
408 			/* swidth */ (640 * 910 + 780 / 2) / 780,
409 			/* totalwidth */ 910,
410 			/* sqwidth */ 780,
411 			/* vdelay */ 0x1a,
412 			/* sheight */ 480,
413 			/* extraheight */ 0,
414 			/* videostart0 */ 23)
415 	},{
416 		.v4l2_id        = V4L2_STD_PAL_N,
417 		.name           = "PAL-N",
418 		.Fsc            = 35468950,
419 		.swidth         = 768,
420 		.sheight        = 576,
421 		.totalwidth     = 1135,
422 		.adelay         = 0x7f,
423 		.bdelay         = 0x72,
424 		.iform          = (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
425 		.scaledtwidth   = 944,
426 		.hdelayx1       = 186,
427 		.hactivex1      = 922,
428 		.vdelay         = 0x20,
429 		.vbipack        = 144,
430 		.sram           = -1,
431 		.vbistart       = { 7, 320 },
432 		CROPCAP(/* minhdelayx1 */ 68,
433 			/* hdelayx1 */ 186,
434 			/* swidth */ (768 * 1135 + 944 / 2) / 944,
435 			/* totalwidth */ 1135,
436 			/* sqwidth */ 944,
437 			/* vdelay */ 0x20,
438 			/* sheight */ 576,
439 			/* extraheight */ 0,
440 			/* videostart0 */ 23)
441 	},{
442 		.v4l2_id        = V4L2_STD_NTSC_M_JP,
443 		.name           = "NTSC-JP",
444 		.Fsc            = 28636363,
445 		.swidth         = 640,
446 		.sheight        = 480,
447 		.totalwidth     = 910,
448 		.adelay         = 0x68,
449 		.bdelay         = 0x5d,
450 		.iform          = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
451 		.scaledtwidth   = 780,
452 		.hdelayx1       = 135,
453 		.hactivex1      = 754,
454 		.vdelay         = 0x16,
455 		.vbipack        = 144,
456 		.sram           = -1,
457 		.vbistart       = { 10, 273 },
458 		CROPCAP(/* minhdelayx1 */ 68,
459 			/* hdelayx1 */ 135,
460 			/* swidth */ (640 * 910 + 780 / 2) / 780,
461 			/* totalwidth */ 910,
462 			/* sqwidth */ 780,
463 			/* vdelay */ 0x16,
464 			/* sheight */ 480,
465 			/* extraheight */ 0,
466 			/* videostart0 */ 23)
467 	},{
468 		/* that one hopefully works with the strange timing
469 		 * which video recorders produce when playing a NTSC
470 		 * tape on a PAL TV ... */
471 		.v4l2_id        = V4L2_STD_PAL_60,
472 		.name           = "PAL-60",
473 		.Fsc            = 35468950,
474 		.swidth         = 924,
475 		.sheight        = 480,
476 		.totalwidth     = 1135,
477 		.adelay         = 0x7f,
478 		.bdelay         = 0x72,
479 		.iform          = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
480 		.scaledtwidth   = 1135,
481 		.hdelayx1       = 186,
482 		.hactivex1      = 924,
483 		.vdelay         = 0x1a,
484 		.vbipack        = 255,
485 		.vtotal         = 524,
486 		.sram           = -1,
487 		.vbistart	= { 10, 273 },
488 		CROPCAP(/* minhdelayx1 */ 68,
489 			/* hdelayx1 */ 186,
490 			/* swidth */ 924,
491 			/* totalwidth */ 1135,
492 			/* sqwidth */ 944,
493 			/* vdelay */ 0x1a,
494 			/* sheight */ 480,
495 			/* extraheight */ 0,
496 			/* videostart0 */ 23)
497 	}
498 };
499 static const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
500 
501 /* ----------------------------------------------------------------------- */
502 /* bttv format list
503    packed pixel formats must come first */
504 static const struct bttv_format formats[] = {
505 	{
506 		.fourcc   = V4L2_PIX_FMT_GREY,
507 		.btformat = BT848_COLOR_FMT_Y8,
508 		.depth    = 8,
509 		.flags    = FORMAT_FLAGS_PACKED,
510 	},{
511 		.fourcc   = V4L2_PIX_FMT_HI240,
512 		.btformat = BT848_COLOR_FMT_RGB8,
513 		.depth    = 8,
514 		.flags    = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
515 	},{
516 		.fourcc   = V4L2_PIX_FMT_RGB555,
517 		.btformat = BT848_COLOR_FMT_RGB15,
518 		.depth    = 16,
519 		.flags    = FORMAT_FLAGS_PACKED,
520 	},{
521 		.fourcc   = V4L2_PIX_FMT_RGB555X,
522 		.btformat = BT848_COLOR_FMT_RGB15,
523 		.btswap   = 0x03, /* byteswap */
524 		.depth    = 16,
525 		.flags    = FORMAT_FLAGS_PACKED,
526 	},{
527 		.fourcc   = V4L2_PIX_FMT_RGB565,
528 		.btformat = BT848_COLOR_FMT_RGB16,
529 		.depth    = 16,
530 		.flags    = FORMAT_FLAGS_PACKED,
531 	},{
532 		.fourcc   = V4L2_PIX_FMT_RGB565X,
533 		.btformat = BT848_COLOR_FMT_RGB16,
534 		.btswap   = 0x03, /* byteswap */
535 		.depth    = 16,
536 		.flags    = FORMAT_FLAGS_PACKED,
537 	},{
538 		.fourcc   = V4L2_PIX_FMT_BGR24,
539 		.btformat = BT848_COLOR_FMT_RGB24,
540 		.depth    = 24,
541 		.flags    = FORMAT_FLAGS_PACKED,
542 	},{
543 		.fourcc   = V4L2_PIX_FMT_BGR32,
544 		.btformat = BT848_COLOR_FMT_RGB32,
545 		.depth    = 32,
546 		.flags    = FORMAT_FLAGS_PACKED,
547 	},{
548 		.fourcc   = V4L2_PIX_FMT_RGB32,
549 		.btformat = BT848_COLOR_FMT_RGB32,
550 		.btswap   = 0x0f, /* byte+word swap */
551 		.depth    = 32,
552 		.flags    = FORMAT_FLAGS_PACKED,
553 	},{
554 		.fourcc   = V4L2_PIX_FMT_YUYV,
555 		.btformat = BT848_COLOR_FMT_YUY2,
556 		.depth    = 16,
557 		.flags    = FORMAT_FLAGS_PACKED,
558 	},{
559 		.fourcc   = V4L2_PIX_FMT_UYVY,
560 		.btformat = BT848_COLOR_FMT_YUY2,
561 		.btswap   = 0x03, /* byteswap */
562 		.depth    = 16,
563 		.flags    = FORMAT_FLAGS_PACKED,
564 	},{
565 		.fourcc   = V4L2_PIX_FMT_YUV422P,
566 		.btformat = BT848_COLOR_FMT_YCrCb422,
567 		.depth    = 16,
568 		.flags    = FORMAT_FLAGS_PLANAR,
569 		.hshift   = 1,
570 		.vshift   = 0,
571 	},{
572 		.fourcc   = V4L2_PIX_FMT_YUV420,
573 		.btformat = BT848_COLOR_FMT_YCrCb422,
574 		.depth    = 12,
575 		.flags    = FORMAT_FLAGS_PLANAR,
576 		.hshift   = 1,
577 		.vshift   = 1,
578 	},{
579 		.fourcc   = V4L2_PIX_FMT_YVU420,
580 		.btformat = BT848_COLOR_FMT_YCrCb422,
581 		.depth    = 12,
582 		.flags    = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
583 		.hshift   = 1,
584 		.vshift   = 1,
585 	},{
586 		.fourcc   = V4L2_PIX_FMT_YUV411P,
587 		.btformat = BT848_COLOR_FMT_YCrCb411,
588 		.depth    = 12,
589 		.flags    = FORMAT_FLAGS_PLANAR,
590 		.hshift   = 2,
591 		.vshift   = 0,
592 	},{
593 		.fourcc   = V4L2_PIX_FMT_YUV410,
594 		.btformat = BT848_COLOR_FMT_YCrCb411,
595 		.depth    = 9,
596 		.flags    = FORMAT_FLAGS_PLANAR,
597 		.hshift   = 2,
598 		.vshift   = 2,
599 	},{
600 		.fourcc   = V4L2_PIX_FMT_YVU410,
601 		.btformat = BT848_COLOR_FMT_YCrCb411,
602 		.depth    = 9,
603 		.flags    = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
604 		.hshift   = 2,
605 		.vshift   = 2,
606 	},{
607 		.fourcc   = -1,
608 		.btformat = BT848_COLOR_FMT_RAW,
609 		.depth    = 8,
610 		.flags    = FORMAT_FLAGS_RAW,
611 	}
612 };
613 static const unsigned int FORMATS = ARRAY_SIZE(formats);
614 
615 /* ----------------------------------------------------------------------- */
616 /* resource management                                                     */
617 
618 /*
619    RESOURCE_    allocated by                freed by
620 
621    VIDEO_READ   bttv_read 1)                bttv_read 2)
622 
623    VIDEO_STREAM VIDIOC_STREAMON             VIDIOC_STREAMOFF
624 		 VIDIOC_QBUF 1)              bttv_release
625 		 VIDIOCMCAPTURE 1)
626 
627    OVERLAY	 VIDIOCCAPTURE on            VIDIOCCAPTURE off
628 		 VIDIOC_OVERLAY on           VIDIOC_OVERLAY off
629 		 3)                          bttv_release
630 
631    VBI		 VIDIOC_STREAMON             VIDIOC_STREAMOFF
632 		 VIDIOC_QBUF 1)              bttv_release
633 		 bttv_read, bttv_poll 1) 4)
634 
635    1) The resource must be allocated when we enter buffer prepare functions
636       and remain allocated while buffers are in the DMA queue.
637    2) This is a single frame read.
638    3) VIDIOC_S_FBUF and VIDIOC_S_FMT (OVERLAY) still work when
639       RESOURCE_OVERLAY is allocated.
640    4) This is a continuous read, implies VIDIOC_STREAMON.
641 
642    Note this driver permits video input and standard changes regardless if
643    resources are allocated.
644 */
645 
646 #define VBI_RESOURCES (RESOURCE_VBI)
647 #define VIDEO_RESOURCES (RESOURCE_VIDEO_READ | \
648 			 RESOURCE_VIDEO_STREAM | \
649 			 RESOURCE_OVERLAY)
650 
651 static
652 int check_alloc_btres_lock(struct bttv *btv, struct bttv_fh *fh, int bit)
653 {
654 	int xbits; /* mutual exclusive resources */
655 
656 	if (fh->resources & bit)
657 		/* have it already allocated */
658 		return 1;
659 
660 	xbits = bit;
661 	if (bit & (RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM))
662 		xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM;
663 
664 	/* is it free? */
665 	if (btv->resources & xbits) {
666 		/* no, someone else uses it */
667 		goto fail;
668 	}
669 
670 	if ((bit & VIDEO_RESOURCES)
671 	    && 0 == (btv->resources & VIDEO_RESOURCES)) {
672 		/* Do crop - use current, don't - use default parameters. */
673 		__s32 top = btv->crop[!!fh->do_crop].rect.top;
674 
675 		if (btv->vbi_end > top)
676 			goto fail;
677 
678 		/* We cannot capture the same line as video and VBI data.
679 		   Claim scan lines crop[].rect.top to bottom. */
680 		btv->crop_start = top;
681 	} else if (bit & VBI_RESOURCES) {
682 		__s32 end = fh->vbi_fmt.end;
683 
684 		if (end > btv->crop_start)
685 			goto fail;
686 
687 		/* Claim scan lines above fh->vbi_fmt.end. */
688 		btv->vbi_end = end;
689 	}
690 
691 	/* it's free, grab it */
692 	fh->resources  |= bit;
693 	btv->resources |= bit;
694 	return 1;
695 
696  fail:
697 	return 0;
698 }
699 
700 static
701 int check_btres(struct bttv_fh *fh, int bit)
702 {
703 	return (fh->resources & bit);
704 }
705 
706 static
707 int locked_btres(struct bttv *btv, int bit)
708 {
709 	return (btv->resources & bit);
710 }
711 
712 /* Call with btv->lock down. */
713 static void
714 disclaim_vbi_lines(struct bttv *btv)
715 {
716 	btv->vbi_end = 0;
717 }
718 
719 /* Call with btv->lock down. */
720 static void
721 disclaim_video_lines(struct bttv *btv)
722 {
723 	const struct bttv_tvnorm *tvnorm;
724 	u8 crop;
725 
726 	tvnorm = &bttv_tvnorms[btv->tvnorm];
727 	btv->crop_start = tvnorm->cropcap.bounds.top
728 		+ tvnorm->cropcap.bounds.height;
729 
730 	/* VBI capturing ends at VDELAY, start of video capturing, no
731 	   matter how many lines the VBI RISC program expects. When video
732 	   capturing is off, it shall no longer "preempt" VBI capturing,
733 	   so we set VDELAY to maximum. */
734 	crop = btread(BT848_E_CROP) | 0xc0;
735 	btwrite(crop, BT848_E_CROP);
736 	btwrite(0xfe, BT848_E_VDELAY_LO);
737 	btwrite(crop, BT848_O_CROP);
738 	btwrite(0xfe, BT848_O_VDELAY_LO);
739 }
740 
741 static
742 void free_btres_lock(struct bttv *btv, struct bttv_fh *fh, int bits)
743 {
744 	if ((fh->resources & bits) != bits) {
745 		/* trying to free resources not allocated by us ... */
746 		pr_err("BUG! (btres)\n");
747 	}
748 	fh->resources  &= ~bits;
749 	btv->resources &= ~bits;
750 
751 	bits = btv->resources;
752 
753 	if (0 == (bits & VIDEO_RESOURCES))
754 		disclaim_video_lines(btv);
755 
756 	if (0 == (bits & VBI_RESOURCES))
757 		disclaim_vbi_lines(btv);
758 }
759 
760 /* ----------------------------------------------------------------------- */
761 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC          */
762 
763 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
764    PLL_X = Reference pre-divider (0=1, 1=2)
765    PLL_C = Post divider (0=6, 1=4)
766    PLL_I = Integer input
767    PLL_F = Fractional input
768 
769    F_input = 28.636363 MHz:
770    PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
771 */
772 
773 static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
774 {
775 	unsigned char fl, fh, fi;
776 
777 	/* prevent overflows */
778 	fin/=4;
779 	fout/=4;
780 
781 	fout*=12;
782 	fi=fout/fin;
783 
784 	fout=(fout%fin)*256;
785 	fh=fout/fin;
786 
787 	fout=(fout%fin)*256;
788 	fl=fout/fin;
789 
790 	btwrite(fl, BT848_PLL_F_LO);
791 	btwrite(fh, BT848_PLL_F_HI);
792 	btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
793 }
794 
795 static void set_pll(struct bttv *btv)
796 {
797 	int i;
798 
799 	if (!btv->pll.pll_crystal)
800 		return;
801 
802 	if (btv->pll.pll_ofreq == btv->pll.pll_current) {
803 		dprintk("%d: PLL: no change required\n", btv->c.nr);
804 		return;
805 	}
806 
807 	if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
808 		/* no PLL needed */
809 		if (btv->pll.pll_current == 0)
810 			return;
811 		if (bttv_verbose)
812 			pr_info("%d: PLL can sleep, using XTAL (%d)\n",
813 				btv->c.nr, btv->pll.pll_ifreq);
814 		btwrite(0x00,BT848_TGCTRL);
815 		btwrite(0x00,BT848_PLL_XCI);
816 		btv->pll.pll_current = 0;
817 		return;
818 	}
819 
820 	if (bttv_verbose)
821 		pr_info("%d: Setting PLL: %d => %d (needs up to 100ms)\n",
822 			btv->c.nr,
823 			btv->pll.pll_ifreq, btv->pll.pll_ofreq);
824 	set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
825 
826 	for (i=0; i<10; i++) {
827 		/*  Let other people run while the PLL stabilizes */
828 		msleep(10);
829 
830 		if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
831 			btwrite(0,BT848_DSTATUS);
832 		} else {
833 			btwrite(0x08,BT848_TGCTRL);
834 			btv->pll.pll_current = btv->pll.pll_ofreq;
835 			if (bttv_verbose)
836 				pr_info("PLL set ok\n");
837 			return;
838 		}
839 	}
840 	btv->pll.pll_current = -1;
841 	if (bttv_verbose)
842 		pr_info("Setting PLL failed\n");
843 	return;
844 }
845 
846 /* used to switch between the bt848's analog/digital video capture modes */
847 static void bt848A_set_timing(struct bttv *btv)
848 {
849 	int i, len;
850 	int table_idx = bttv_tvnorms[btv->tvnorm].sram;
851 	int fsc       = bttv_tvnorms[btv->tvnorm].Fsc;
852 
853 	if (btv->input == btv->dig) {
854 		dprintk("%d: load digital timing table (table_idx=%d)\n",
855 			btv->c.nr,table_idx);
856 
857 		/* timing change...reset timing generator address */
858 		btwrite(0x00, BT848_TGCTRL);
859 		btwrite(0x02, BT848_TGCTRL);
860 		btwrite(0x00, BT848_TGCTRL);
861 
862 		len=SRAM_Table[table_idx][0];
863 		for(i = 1; i <= len; i++)
864 			btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
865 		btv->pll.pll_ofreq = 27000000;
866 
867 		set_pll(btv);
868 		btwrite(0x11, BT848_TGCTRL);
869 		btwrite(0x41, BT848_DVSIF);
870 	} else {
871 		btv->pll.pll_ofreq = fsc;
872 		set_pll(btv);
873 		btwrite(0x0, BT848_DVSIF);
874 	}
875 }
876 
877 /* ----------------------------------------------------------------------- */
878 
879 static void bt848_bright(struct bttv *btv, int bright)
880 {
881 	int value;
882 
883 	// printk("set bright: %d\n", bright); // DEBUG
884 	btv->bright = bright;
885 
886 	/* We want -128 to 127 we get 0-65535 */
887 	value = (bright >> 8) - 128;
888 	btwrite(value & 0xff, BT848_BRIGHT);
889 }
890 
891 static void bt848_hue(struct bttv *btv, int hue)
892 {
893 	int value;
894 
895 	btv->hue = hue;
896 
897 	/* -128 to 127 */
898 	value = (hue >> 8) - 128;
899 	btwrite(value & 0xff, BT848_HUE);
900 }
901 
902 static void bt848_contrast(struct bttv *btv, int cont)
903 {
904 	int value,hibit;
905 
906 	btv->contrast = cont;
907 
908 	/* 0-511 */
909 	value = (cont  >> 7);
910 	hibit = (value >> 6) & 4;
911 	btwrite(value & 0xff, BT848_CONTRAST_LO);
912 	btaor(hibit, ~4, BT848_E_CONTROL);
913 	btaor(hibit, ~4, BT848_O_CONTROL);
914 }
915 
916 static void bt848_sat(struct bttv *btv, int color)
917 {
918 	int val_u,val_v,hibits;
919 
920 	btv->saturation = color;
921 
922 	/* 0-511 for the color */
923 	val_u   = ((color * btv->opt_uv_ratio) / 50) >> 7;
924 	val_v   = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
925 	hibits  = (val_u >> 7) & 2;
926 	hibits |= (val_v >> 8) & 1;
927 	btwrite(val_u & 0xff, BT848_SAT_U_LO);
928 	btwrite(val_v & 0xff, BT848_SAT_V_LO);
929 	btaor(hibits, ~3, BT848_E_CONTROL);
930 	btaor(hibits, ~3, BT848_O_CONTROL);
931 }
932 
933 /* ----------------------------------------------------------------------- */
934 
935 static int
936 video_mux(struct bttv *btv, unsigned int input)
937 {
938 	int mux,mask2;
939 
940 	if (input >= bttv_tvcards[btv->c.type].video_inputs)
941 		return -EINVAL;
942 
943 	/* needed by RemoteVideo MX */
944 	mask2 = bttv_tvcards[btv->c.type].gpiomask2;
945 	if (mask2)
946 		gpio_inout(mask2,mask2);
947 
948 	if (input == btv->svhs)  {
949 		btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
950 		btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
951 	} else {
952 		btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
953 		btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
954 	}
955 	mux = bttv_muxsel(btv, input);
956 	btaor(mux<<5, ~(3<<5), BT848_IFORM);
957 	dprintk("%d: video mux: input=%d mux=%d\n", btv->c.nr, input, mux);
958 
959 	/* card specific hook */
960 	if(bttv_tvcards[btv->c.type].muxsel_hook)
961 		bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
962 	return 0;
963 }
964 
965 static char *audio_modes[] = {
966 	"audio: tuner", "audio: radio", "audio: extern",
967 	"audio: intern", "audio: mute"
968 };
969 
970 static void
971 audio_mux_gpio(struct bttv *btv, int input, int mute)
972 {
973 	int gpio_val, signal, mute_gpio;
974 
975 	gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
976 		   bttv_tvcards[btv->c.type].gpiomask);
977 	signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
978 
979 	/* automute */
980 	mute_gpio = mute || (btv->opt_automute && (!signal || !btv->users)
981 				&& !btv->has_radio_tuner);
982 
983 	if (mute_gpio)
984 		gpio_val = bttv_tvcards[btv->c.type].gpiomute;
985 	else
986 		gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
987 
988 	switch (btv->c.type) {
989 	case BTTV_BOARD_VOODOOTV_FM:
990 	case BTTV_BOARD_VOODOOTV_200:
991 		gpio_val = bttv_tda9880_setnorm(btv, gpio_val);
992 		break;
993 
994 	default:
995 		gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
996 	}
997 
998 	if (bttv_gpio)
999 		bttv_gpio_tracking(btv, audio_modes[mute_gpio ? 4 : input]);
1000 }
1001 
1002 static int
1003 audio_mute(struct bttv *btv, int mute)
1004 {
1005 	struct v4l2_ctrl *ctrl;
1006 
1007 	audio_mux_gpio(btv, btv->audio_input, mute);
1008 
1009 	if (btv->sd_msp34xx) {
1010 		ctrl = v4l2_ctrl_find(btv->sd_msp34xx->ctrl_handler, V4L2_CID_AUDIO_MUTE);
1011 		if (ctrl)
1012 			v4l2_ctrl_s_ctrl(ctrl, mute);
1013 	}
1014 	if (btv->sd_tvaudio) {
1015 		ctrl = v4l2_ctrl_find(btv->sd_tvaudio->ctrl_handler, V4L2_CID_AUDIO_MUTE);
1016 		if (ctrl)
1017 			v4l2_ctrl_s_ctrl(ctrl, mute);
1018 	}
1019 	if (btv->sd_tda7432) {
1020 		ctrl = v4l2_ctrl_find(btv->sd_tda7432->ctrl_handler, V4L2_CID_AUDIO_MUTE);
1021 		if (ctrl)
1022 			v4l2_ctrl_s_ctrl(ctrl, mute);
1023 	}
1024 	return 0;
1025 }
1026 
1027 static int
1028 audio_input(struct bttv *btv, int input)
1029 {
1030 	audio_mux_gpio(btv, input, btv->mute);
1031 
1032 	if (btv->sd_msp34xx) {
1033 		u32 in;
1034 
1035 		/* Note: the inputs tuner/radio/extern/intern are translated
1036 		   to msp routings. This assumes common behavior for all msp3400
1037 		   based TV cards. When this assumption fails, then the
1038 		   specific MSP routing must be added to the card table.
1039 		   For now this is sufficient. */
1040 		switch (input) {
1041 		case TVAUDIO_INPUT_RADIO:
1042 			/* Some boards need the msp do to the radio demod */
1043 			if (btv->radio_uses_msp_demodulator) {
1044 				in = MSP_INPUT_DEFAULT;
1045 				break;
1046 			}
1047 			in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1048 				    MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1049 			break;
1050 		case TVAUDIO_INPUT_EXTERN:
1051 			in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
1052 				    MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1053 			break;
1054 		case TVAUDIO_INPUT_INTERN:
1055 			/* Yes, this is the same input as for RADIO. I doubt
1056 			   if this is ever used. The only board with an INTERN
1057 			   input is the BTTV_BOARD_AVERMEDIA98. I wonder how
1058 			   that was tested. My guess is that the whole INTERN
1059 			   input does not work. */
1060 			in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1061 				    MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1062 			break;
1063 		case TVAUDIO_INPUT_TUNER:
1064 		default:
1065 			/* This is the only card that uses TUNER2, and afaik,
1066 			   is the only difference between the VOODOOTV_FM
1067 			   and VOODOOTV_200 */
1068 			if (btv->c.type == BTTV_BOARD_VOODOOTV_200)
1069 				in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \
1070 					MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER);
1071 			else
1072 				in = MSP_INPUT_DEFAULT;
1073 			break;
1074 		}
1075 		v4l2_subdev_call(btv->sd_msp34xx, audio, s_routing,
1076 			       in, MSP_OUTPUT_DEFAULT, 0);
1077 	}
1078 	if (btv->sd_tvaudio) {
1079 		v4l2_subdev_call(btv->sd_tvaudio, audio, s_routing,
1080 				 input, 0, 0);
1081 	}
1082 	return 0;
1083 }
1084 
1085 static void
1086 bttv_crop_calc_limits(struct bttv_crop *c)
1087 {
1088 	/* Scale factor min. 1:1, max. 16:1. Min. image size
1089 	   48 x 32. Scaled width must be a multiple of 4. */
1090 
1091 	if (1) {
1092 		/* For bug compatibility with VIDIOCGCAP and image
1093 		   size checks in earlier driver versions. */
1094 		c->min_scaled_width = 48;
1095 		c->min_scaled_height = 32;
1096 	} else {
1097 		c->min_scaled_width =
1098 			(max_t(unsigned int, 48, c->rect.width >> 4) + 3) & ~3;
1099 		c->min_scaled_height =
1100 			max_t(unsigned int, 32, c->rect.height >> 4);
1101 	}
1102 
1103 	c->max_scaled_width  = c->rect.width & ~3;
1104 	c->max_scaled_height = c->rect.height;
1105 }
1106 
1107 static void
1108 bttv_crop_reset(struct bttv_crop *c, unsigned int norm)
1109 {
1110 	c->rect = bttv_tvnorms[norm].cropcap.defrect;
1111 	bttv_crop_calc_limits(c);
1112 }
1113 
1114 /* Call with btv->lock down. */
1115 static int
1116 set_tvnorm(struct bttv *btv, unsigned int norm)
1117 {
1118 	const struct bttv_tvnorm *tvnorm;
1119 	v4l2_std_id id;
1120 
1121 	BUG_ON(norm >= BTTV_TVNORMS);
1122 	BUG_ON(btv->tvnorm >= BTTV_TVNORMS);
1123 
1124 	tvnorm = &bttv_tvnorms[norm];
1125 
1126 	if (memcmp(&bttv_tvnorms[btv->tvnorm].cropcap, &tvnorm->cropcap,
1127 		    sizeof (tvnorm->cropcap))) {
1128 		bttv_crop_reset(&btv->crop[0], norm);
1129 		btv->crop[1] = btv->crop[0]; /* current = default */
1130 
1131 		if (0 == (btv->resources & VIDEO_RESOURCES)) {
1132 			btv->crop_start = tvnorm->cropcap.bounds.top
1133 				+ tvnorm->cropcap.bounds.height;
1134 		}
1135 	}
1136 
1137 	btv->tvnorm = norm;
1138 
1139 	btwrite(tvnorm->adelay, BT848_ADELAY);
1140 	btwrite(tvnorm->bdelay, BT848_BDELAY);
1141 	btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1142 	      BT848_IFORM);
1143 	btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1144 	btwrite(1, BT848_VBI_PACK_DEL);
1145 	bt848A_set_timing(btv);
1146 
1147 	switch (btv->c.type) {
1148 	case BTTV_BOARD_VOODOOTV_FM:
1149 	case BTTV_BOARD_VOODOOTV_200:
1150 		bttv_tda9880_setnorm(btv, gpio_read());
1151 		break;
1152 	}
1153 	id = tvnorm->v4l2_id;
1154 	bttv_call_all(btv, video, s_std, id);
1155 
1156 	return 0;
1157 }
1158 
1159 /* Call with btv->lock down. */
1160 static void
1161 set_input(struct bttv *btv, unsigned int input, unsigned int norm)
1162 {
1163 	unsigned long flags;
1164 
1165 	btv->input = input;
1166 	if (irq_iswitch) {
1167 		spin_lock_irqsave(&btv->s_lock,flags);
1168 		if (btv->curr.frame_irq) {
1169 			/* active capture -> delayed input switch */
1170 			btv->new_input = input;
1171 		} else {
1172 			video_mux(btv,input);
1173 		}
1174 		spin_unlock_irqrestore(&btv->s_lock,flags);
1175 	} else {
1176 		video_mux(btv,input);
1177 	}
1178 	btv->audio_input = (btv->tuner_type != TUNER_ABSENT && input == 0) ?
1179 				TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN;
1180 	audio_input(btv, btv->audio_input);
1181 	set_tvnorm(btv, norm);
1182 }
1183 
1184 static void init_irqreg(struct bttv *btv)
1185 {
1186 	/* clear status */
1187 	btwrite(0xfffffUL, BT848_INT_STAT);
1188 
1189 	if (bttv_tvcards[btv->c.type].no_video) {
1190 		/* i2c only */
1191 		btwrite(BT848_INT_I2CDONE,
1192 			BT848_INT_MASK);
1193 	} else {
1194 		/* full video */
1195 		btwrite((btv->triton1)  |
1196 			(btv->gpioirq ? BT848_INT_GPINT : 0) |
1197 			BT848_INT_SCERR |
1198 			(fdsr ? BT848_INT_FDSR : 0) |
1199 			BT848_INT_RISCI | BT848_INT_OCERR |
1200 			BT848_INT_FMTCHG|BT848_INT_HLOCK|
1201 			BT848_INT_I2CDONE,
1202 			BT848_INT_MASK);
1203 	}
1204 }
1205 
1206 static void init_bt848(struct bttv *btv)
1207 {
1208 	if (bttv_tvcards[btv->c.type].no_video) {
1209 		/* very basic init only */
1210 		init_irqreg(btv);
1211 		return;
1212 	}
1213 
1214 	btwrite(0x00, BT848_CAP_CTL);
1215 	btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1216 	btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1217 
1218 	/* set planar and packed mode trigger points and         */
1219 	/* set rising edge of inverted GPINTR pin as irq trigger */
1220 	btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1221 		BT848_GPIO_DMA_CTL_PLTP1_16|
1222 		BT848_GPIO_DMA_CTL_PLTP23_16|
1223 		BT848_GPIO_DMA_CTL_GPINTC|
1224 		BT848_GPIO_DMA_CTL_GPINTI,
1225 		BT848_GPIO_DMA_CTL);
1226 
1227 	btwrite(0x20, BT848_E_VSCALE_HI);
1228 	btwrite(0x20, BT848_O_VSCALE_HI);
1229 
1230 	v4l2_ctrl_handler_setup(&btv->ctrl_handler);
1231 
1232 	/* interrupt */
1233 	init_irqreg(btv);
1234 }
1235 
1236 static void bttv_reinit_bt848(struct bttv *btv)
1237 {
1238 	unsigned long flags;
1239 
1240 	if (bttv_verbose)
1241 		pr_info("%d: reset, reinitialize\n", btv->c.nr);
1242 	spin_lock_irqsave(&btv->s_lock,flags);
1243 	btv->errors=0;
1244 	bttv_set_dma(btv,0);
1245 	spin_unlock_irqrestore(&btv->s_lock,flags);
1246 
1247 	init_bt848(btv);
1248 	btv->pll.pll_current = -1;
1249 	set_input(btv, btv->input, btv->tvnorm);
1250 }
1251 
1252 static int bttv_s_ctrl(struct v4l2_ctrl *c)
1253 {
1254 	struct bttv *btv = container_of(c->handler, struct bttv, ctrl_handler);
1255 	int val;
1256 
1257 	switch (c->id) {
1258 	case V4L2_CID_BRIGHTNESS:
1259 		bt848_bright(btv, c->val);
1260 		break;
1261 	case V4L2_CID_HUE:
1262 		bt848_hue(btv, c->val);
1263 		break;
1264 	case V4L2_CID_CONTRAST:
1265 		bt848_contrast(btv, c->val);
1266 		break;
1267 	case V4L2_CID_SATURATION:
1268 		bt848_sat(btv, c->val);
1269 		break;
1270 	case V4L2_CID_COLOR_KILLER:
1271 		if (c->val) {
1272 			btor(BT848_SCLOOP_CKILL, BT848_E_SCLOOP);
1273 			btor(BT848_SCLOOP_CKILL, BT848_O_SCLOOP);
1274 		} else {
1275 			btand(~BT848_SCLOOP_CKILL, BT848_E_SCLOOP);
1276 			btand(~BT848_SCLOOP_CKILL, BT848_O_SCLOOP);
1277 		}
1278 		break;
1279 	case V4L2_CID_AUDIO_MUTE:
1280 		audio_mute(btv, c->val);
1281 		btv->mute = c->val;
1282 		break;
1283 	case V4L2_CID_AUDIO_VOLUME:
1284 		btv->volume_gpio(btv, c->val);
1285 		break;
1286 
1287 	case V4L2_CID_CHROMA_AGC:
1288 		val = c->val ? BT848_SCLOOP_CAGC : 0;
1289 		btwrite(val, BT848_E_SCLOOP);
1290 		btwrite(val, BT848_O_SCLOOP);
1291 		break;
1292 	case V4L2_CID_PRIVATE_COMBFILTER:
1293 		btv->opt_combfilter = c->val;
1294 		break;
1295 	case V4L2_CID_PRIVATE_LUMAFILTER:
1296 		if (c->val) {
1297 			btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1298 			btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1299 		} else {
1300 			btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1301 			btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1302 		}
1303 		break;
1304 	case V4L2_CID_PRIVATE_AUTOMUTE:
1305 		btv->opt_automute = c->val;
1306 		break;
1307 	case V4L2_CID_PRIVATE_AGC_CRUSH:
1308 		btwrite(BT848_ADC_RESERVED |
1309 				(c->val ? BT848_ADC_CRUSH : 0),
1310 				BT848_ADC);
1311 		break;
1312 	case V4L2_CID_PRIVATE_VCR_HACK:
1313 		btv->opt_vcr_hack = c->val;
1314 		break;
1315 	case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1316 		btwrite(c->val, BT848_WC_UP);
1317 		break;
1318 	case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1319 		btwrite(c->val, BT848_WC_DOWN);
1320 		break;
1321 	case V4L2_CID_PRIVATE_UV_RATIO:
1322 		btv->opt_uv_ratio = c->val;
1323 		bt848_sat(btv, btv->saturation);
1324 		break;
1325 	case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1326 		btaor((c->val << 7), ~BT848_OFORM_RANGE, BT848_OFORM);
1327 		break;
1328 	case V4L2_CID_PRIVATE_CORING:
1329 		btaor((c->val << 5), ~BT848_OFORM_CORE32, BT848_OFORM);
1330 		break;
1331 	default:
1332 		return -EINVAL;
1333 	}
1334 	return 0;
1335 }
1336 
1337 /* ----------------------------------------------------------------------- */
1338 
1339 static const struct v4l2_ctrl_ops bttv_ctrl_ops = {
1340 	.s_ctrl = bttv_s_ctrl,
1341 };
1342 
1343 static struct v4l2_ctrl_config bttv_ctrl_combfilter = {
1344 	.ops = &bttv_ctrl_ops,
1345 	.id = V4L2_CID_PRIVATE_COMBFILTER,
1346 	.name = "Comb Filter",
1347 	.type = V4L2_CTRL_TYPE_BOOLEAN,
1348 	.min = 0,
1349 	.max = 1,
1350 	.step = 1,
1351 	.def = 1,
1352 };
1353 
1354 static struct v4l2_ctrl_config bttv_ctrl_automute = {
1355 	.ops = &bttv_ctrl_ops,
1356 	.id = V4L2_CID_PRIVATE_AUTOMUTE,
1357 	.name = "Auto Mute",
1358 	.type = V4L2_CTRL_TYPE_BOOLEAN,
1359 	.min = 0,
1360 	.max = 1,
1361 	.step = 1,
1362 	.def = 1,
1363 };
1364 
1365 static struct v4l2_ctrl_config bttv_ctrl_lumafilter = {
1366 	.ops = &bttv_ctrl_ops,
1367 	.id = V4L2_CID_PRIVATE_LUMAFILTER,
1368 	.name = "Luma Decimation Filter",
1369 	.type = V4L2_CTRL_TYPE_BOOLEAN,
1370 	.min = 0,
1371 	.max = 1,
1372 	.step = 1,
1373 	.def = 1,
1374 };
1375 
1376 static struct v4l2_ctrl_config bttv_ctrl_agc_crush = {
1377 	.ops = &bttv_ctrl_ops,
1378 	.id = V4L2_CID_PRIVATE_AGC_CRUSH,
1379 	.name = "AGC Crush",
1380 	.type = V4L2_CTRL_TYPE_BOOLEAN,
1381 	.min = 0,
1382 	.max = 1,
1383 	.step = 1,
1384 	.def = 1,
1385 };
1386 
1387 static struct v4l2_ctrl_config bttv_ctrl_vcr_hack = {
1388 	.ops = &bttv_ctrl_ops,
1389 	.id = V4L2_CID_PRIVATE_VCR_HACK,
1390 	.name = "VCR Hack",
1391 	.type = V4L2_CTRL_TYPE_BOOLEAN,
1392 	.min = 0,
1393 	.max = 1,
1394 	.step = 1,
1395 	.def = 1,
1396 };
1397 
1398 static struct v4l2_ctrl_config bttv_ctrl_whitecrush_lower = {
1399 	.ops = &bttv_ctrl_ops,
1400 	.id = V4L2_CID_PRIVATE_WHITECRUSH_LOWER,
1401 	.name = "Whitecrush Lower",
1402 	.type = V4L2_CTRL_TYPE_INTEGER,
1403 	.min = 0,
1404 	.max = 255,
1405 	.step = 1,
1406 	.def = 0x7f,
1407 };
1408 
1409 static struct v4l2_ctrl_config bttv_ctrl_whitecrush_upper = {
1410 	.ops = &bttv_ctrl_ops,
1411 	.id = V4L2_CID_PRIVATE_WHITECRUSH_UPPER,
1412 	.name = "Whitecrush Upper",
1413 	.type = V4L2_CTRL_TYPE_INTEGER,
1414 	.min = 0,
1415 	.max = 255,
1416 	.step = 1,
1417 	.def = 0xcf,
1418 };
1419 
1420 static struct v4l2_ctrl_config bttv_ctrl_uv_ratio = {
1421 	.ops = &bttv_ctrl_ops,
1422 	.id = V4L2_CID_PRIVATE_UV_RATIO,
1423 	.name = "UV Ratio",
1424 	.type = V4L2_CTRL_TYPE_INTEGER,
1425 	.min = 0,
1426 	.max = 100,
1427 	.step = 1,
1428 	.def = 50,
1429 };
1430 
1431 static struct v4l2_ctrl_config bttv_ctrl_full_luma = {
1432 	.ops = &bttv_ctrl_ops,
1433 	.id = V4L2_CID_PRIVATE_FULL_LUMA_RANGE,
1434 	.name = "Full Luma Range",
1435 	.type = V4L2_CTRL_TYPE_BOOLEAN,
1436 	.min = 0,
1437 	.max = 1,
1438 	.step = 1,
1439 };
1440 
1441 static struct v4l2_ctrl_config bttv_ctrl_coring = {
1442 	.ops = &bttv_ctrl_ops,
1443 	.id = V4L2_CID_PRIVATE_CORING,
1444 	.name = "Coring",
1445 	.type = V4L2_CTRL_TYPE_INTEGER,
1446 	.min = 0,
1447 	.max = 3,
1448 	.step = 1,
1449 };
1450 
1451 
1452 /* ----------------------------------------------------------------------- */
1453 
1454 void bttv_gpio_tracking(struct bttv *btv, char *comment)
1455 {
1456 	unsigned int outbits, data;
1457 	outbits = btread(BT848_GPIO_OUT_EN);
1458 	data    = btread(BT848_GPIO_DATA);
1459 	pr_debug("%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1460 		 btv->c.nr, outbits, data & outbits, data & ~outbits, comment);
1461 }
1462 
1463 static void bttv_field_count(struct bttv *btv)
1464 {
1465 	int need_count = 0;
1466 
1467 	if (btv->users)
1468 		need_count++;
1469 
1470 	if (need_count) {
1471 		/* start field counter */
1472 		btor(BT848_INT_VSYNC,BT848_INT_MASK);
1473 	} else {
1474 		/* stop field counter */
1475 		btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1476 		btv->field_count = 0;
1477 	}
1478 }
1479 
1480 static const struct bttv_format*
1481 format_by_fourcc(int fourcc)
1482 {
1483 	unsigned int i;
1484 
1485 	for (i = 0; i < FORMATS; i++) {
1486 		if (-1 == formats[i].fourcc)
1487 			continue;
1488 		if (formats[i].fourcc == fourcc)
1489 			return formats+i;
1490 	}
1491 	return NULL;
1492 }
1493 
1494 /* ----------------------------------------------------------------------- */
1495 /* misc helpers                                                            */
1496 
1497 static int
1498 bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1499 		    struct bttv_buffer *new)
1500 {
1501 	struct bttv_buffer *old;
1502 	unsigned long flags;
1503 
1504 	dprintk("switch_overlay: enter [new=%p]\n", new);
1505 	if (new)
1506 		new->vb.state = VIDEOBUF_DONE;
1507 	spin_lock_irqsave(&btv->s_lock,flags);
1508 	old = btv->screen;
1509 	btv->screen = new;
1510 	btv->loop_irq |= 1;
1511 	bttv_set_dma(btv, 0x03);
1512 	spin_unlock_irqrestore(&btv->s_lock,flags);
1513 	if (NULL != old) {
1514 		dprintk("switch_overlay: old=%p state is %d\n",
1515 			old, old->vb.state);
1516 		bttv_dma_free(&fh->cap,btv, old);
1517 		kfree(old);
1518 	}
1519 	if (NULL == new)
1520 		free_btres_lock(btv,fh,RESOURCE_OVERLAY);
1521 	dprintk("switch_overlay: done\n");
1522 	return 0;
1523 }
1524 
1525 /* ----------------------------------------------------------------------- */
1526 /* video4linux (1) interface                                               */
1527 
1528 static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1529 			       struct bttv_buffer *buf,
1530 			       const struct bttv_format *fmt,
1531 			       unsigned int width, unsigned int height,
1532 			       enum v4l2_field field)
1533 {
1534 	struct bttv_fh *fh = q->priv_data;
1535 	int redo_dma_risc = 0;
1536 	struct bttv_crop c;
1537 	int norm;
1538 	int rc;
1539 
1540 	/* check settings */
1541 	if (NULL == fmt)
1542 		return -EINVAL;
1543 	if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1544 		width  = RAW_BPL;
1545 		height = RAW_LINES*2;
1546 		if (width*height > buf->vb.bsize)
1547 			return -EINVAL;
1548 		buf->vb.size = buf->vb.bsize;
1549 
1550 		/* Make sure tvnorm and vbi_end remain consistent
1551 		   until we're done. */
1552 
1553 		norm = btv->tvnorm;
1554 
1555 		/* In this mode capturing always starts at defrect.top
1556 		   (default VDELAY), ignoring cropping parameters. */
1557 		if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
1558 			return -EINVAL;
1559 		}
1560 
1561 		c.rect = bttv_tvnorms[norm].cropcap.defrect;
1562 	} else {
1563 		norm = btv->tvnorm;
1564 		c = btv->crop[!!fh->do_crop];
1565 
1566 		if (width < c.min_scaled_width ||
1567 		    width > c.max_scaled_width ||
1568 		    height < c.min_scaled_height)
1569 			return -EINVAL;
1570 
1571 		switch (field) {
1572 		case V4L2_FIELD_TOP:
1573 		case V4L2_FIELD_BOTTOM:
1574 		case V4L2_FIELD_ALTERNATE:
1575 			/* btv->crop counts frame lines. Max. scale
1576 			   factor is 16:1 for frames, 8:1 for fields. */
1577 			if (height * 2 > c.max_scaled_height)
1578 				return -EINVAL;
1579 			break;
1580 
1581 		default:
1582 			if (height > c.max_scaled_height)
1583 				return -EINVAL;
1584 			break;
1585 		}
1586 
1587 		buf->vb.size = (width * height * fmt->depth) >> 3;
1588 		if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
1589 			return -EINVAL;
1590 	}
1591 
1592 	/* alloc + fill struct bttv_buffer (if changed) */
1593 	if (buf->vb.width != width || buf->vb.height != height ||
1594 	    buf->vb.field != field ||
1595 	    buf->tvnorm != norm || buf->fmt != fmt ||
1596 	    buf->crop.top != c.rect.top ||
1597 	    buf->crop.left != c.rect.left ||
1598 	    buf->crop.width != c.rect.width ||
1599 	    buf->crop.height != c.rect.height) {
1600 		buf->vb.width  = width;
1601 		buf->vb.height = height;
1602 		buf->vb.field  = field;
1603 		buf->tvnorm    = norm;
1604 		buf->fmt       = fmt;
1605 		buf->crop      = c.rect;
1606 		redo_dma_risc = 1;
1607 	}
1608 
1609 	/* alloc risc memory */
1610 	if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1611 		redo_dma_risc = 1;
1612 		if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
1613 			goto fail;
1614 	}
1615 
1616 	if (redo_dma_risc)
1617 		if (0 != (rc = bttv_buffer_risc(btv,buf)))
1618 			goto fail;
1619 
1620 	buf->vb.state = VIDEOBUF_PREPARED;
1621 	return 0;
1622 
1623  fail:
1624 	bttv_dma_free(q,btv,buf);
1625 	return rc;
1626 }
1627 
1628 static int
1629 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1630 {
1631 	struct bttv_fh *fh = q->priv_data;
1632 
1633 	*size = fh->fmt->depth*fh->width*fh->height >> 3;
1634 	if (0 == *count)
1635 		*count = gbuffers;
1636 	if (*size * *count > gbuffers * gbufsize)
1637 		*count = (gbuffers * gbufsize) / *size;
1638 	return 0;
1639 }
1640 
1641 static int
1642 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1643 	       enum v4l2_field field)
1644 {
1645 	struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1646 	struct bttv_fh *fh = q->priv_data;
1647 
1648 	return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
1649 				   fh->width, fh->height, field);
1650 }
1651 
1652 static void
1653 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1654 {
1655 	struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1656 	struct bttv_fh *fh = q->priv_data;
1657 	struct bttv    *btv = fh->btv;
1658 
1659 	buf->vb.state = VIDEOBUF_QUEUED;
1660 	list_add_tail(&buf->vb.queue,&btv->capture);
1661 	if (!btv->curr.frame_irq) {
1662 		btv->loop_irq |= 1;
1663 		bttv_set_dma(btv, 0x03);
1664 	}
1665 }
1666 
1667 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1668 {
1669 	struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1670 	struct bttv_fh *fh = q->priv_data;
1671 
1672 	bttv_dma_free(q,fh->btv,buf);
1673 }
1674 
1675 static const struct videobuf_queue_ops bttv_video_qops = {
1676 	.buf_setup    = buffer_setup,
1677 	.buf_prepare  = buffer_prepare,
1678 	.buf_queue    = buffer_queue,
1679 	.buf_release  = buffer_release,
1680 };
1681 
1682 static void radio_enable(struct bttv *btv)
1683 {
1684 	/* Switch to the radio tuner */
1685 	if (!btv->has_radio_tuner) {
1686 		btv->has_radio_tuner = 1;
1687 		bttv_call_all(btv, tuner, s_radio);
1688 		btv->audio_input = TVAUDIO_INPUT_RADIO;
1689 		audio_input(btv, btv->audio_input);
1690 	}
1691 }
1692 
1693 static int bttv_s_std(struct file *file, void *priv, v4l2_std_id id)
1694 {
1695 	struct bttv_fh *fh  = priv;
1696 	struct bttv *btv = fh->btv;
1697 	unsigned int i;
1698 
1699 	for (i = 0; i < BTTV_TVNORMS; i++)
1700 		if (id & bttv_tvnorms[i].v4l2_id)
1701 			break;
1702 	if (i == BTTV_TVNORMS)
1703 		return -EINVAL;
1704 	btv->std = id;
1705 	set_tvnorm(btv, i);
1706 	return 0;
1707 }
1708 
1709 static int bttv_g_std(struct file *file, void *priv, v4l2_std_id *id)
1710 {
1711 	struct bttv_fh *fh  = priv;
1712 	struct bttv *btv = fh->btv;
1713 
1714 	*id = btv->std;
1715 	return 0;
1716 }
1717 
1718 static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id)
1719 {
1720 	struct bttv_fh *fh = f;
1721 	struct bttv *btv = fh->btv;
1722 
1723 	if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1724 		*id &= V4L2_STD_625_50;
1725 	else
1726 		*id &= V4L2_STD_525_60;
1727 	return 0;
1728 }
1729 
1730 static int bttv_enum_input(struct file *file, void *priv,
1731 					struct v4l2_input *i)
1732 {
1733 	struct bttv_fh *fh = priv;
1734 	struct bttv *btv = fh->btv;
1735 
1736 	if (i->index >= bttv_tvcards[btv->c.type].video_inputs)
1737 		return -EINVAL;
1738 
1739 	i->type     = V4L2_INPUT_TYPE_CAMERA;
1740 	i->audioset = 0;
1741 
1742 	if (btv->tuner_type != TUNER_ABSENT && i->index == 0) {
1743 		sprintf(i->name, "Television");
1744 		i->type  = V4L2_INPUT_TYPE_TUNER;
1745 		i->tuner = 0;
1746 	} else if (i->index == btv->svhs) {
1747 		sprintf(i->name, "S-Video");
1748 	} else {
1749 		sprintf(i->name, "Composite%d", i->index);
1750 	}
1751 
1752 	if (i->index == btv->input) {
1753 		__u32 dstatus = btread(BT848_DSTATUS);
1754 		if (0 == (dstatus & BT848_DSTATUS_PRES))
1755 			i->status |= V4L2_IN_ST_NO_SIGNAL;
1756 		if (0 == (dstatus & BT848_DSTATUS_HLOC))
1757 			i->status |= V4L2_IN_ST_NO_H_LOCK;
1758 	}
1759 
1760 	i->std = BTTV_NORMS;
1761 	return 0;
1762 }
1763 
1764 static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
1765 {
1766 	struct bttv_fh *fh = priv;
1767 	struct bttv *btv = fh->btv;
1768 
1769 	*i = btv->input;
1770 
1771 	return 0;
1772 }
1773 
1774 static int bttv_s_input(struct file *file, void *priv, unsigned int i)
1775 {
1776 	struct bttv_fh *fh  = priv;
1777 	struct bttv *btv = fh->btv;
1778 
1779 	if (i >= bttv_tvcards[btv->c.type].video_inputs)
1780 		return -EINVAL;
1781 
1782 	set_input(btv, i, btv->tvnorm);
1783 	return 0;
1784 }
1785 
1786 static int bttv_s_tuner(struct file *file, void *priv,
1787 					const struct v4l2_tuner *t)
1788 {
1789 	struct bttv_fh *fh  = priv;
1790 	struct bttv *btv = fh->btv;
1791 
1792 	if (t->index)
1793 		return -EINVAL;
1794 
1795 	bttv_call_all(btv, tuner, s_tuner, t);
1796 
1797 	if (btv->audio_mode_gpio) {
1798 		struct v4l2_tuner copy = *t;
1799 
1800 		btv->audio_mode_gpio(btv, &copy, 1);
1801 	}
1802 	return 0;
1803 }
1804 
1805 static int bttv_g_frequency(struct file *file, void *priv,
1806 					struct v4l2_frequency *f)
1807 {
1808 	struct bttv_fh *fh  = priv;
1809 	struct bttv *btv = fh->btv;
1810 
1811 	if (f->tuner)
1812 		return -EINVAL;
1813 
1814 	if (f->type == V4L2_TUNER_RADIO)
1815 		radio_enable(btv);
1816 	f->frequency = f->type == V4L2_TUNER_RADIO ?
1817 				btv->radio_freq : btv->tv_freq;
1818 
1819 	return 0;
1820 }
1821 
1822 static void bttv_set_frequency(struct bttv *btv, const struct v4l2_frequency *f)
1823 {
1824 	struct v4l2_frequency new_freq = *f;
1825 
1826 	bttv_call_all(btv, tuner, s_frequency, f);
1827 	/* s_frequency may clamp the frequency, so get the actual
1828 	   frequency before assigning radio/tv_freq. */
1829 	bttv_call_all(btv, tuner, g_frequency, &new_freq);
1830 	if (new_freq.type == V4L2_TUNER_RADIO) {
1831 		radio_enable(btv);
1832 		btv->radio_freq = new_freq.frequency;
1833 		if (btv->has_tea575x) {
1834 			btv->tea.freq = btv->radio_freq;
1835 			snd_tea575x_set_freq(&btv->tea);
1836 		}
1837 	} else {
1838 		btv->tv_freq = new_freq.frequency;
1839 	}
1840 }
1841 
1842 static int bttv_s_frequency(struct file *file, void *priv,
1843 					const struct v4l2_frequency *f)
1844 {
1845 	struct bttv_fh *fh  = priv;
1846 	struct bttv *btv = fh->btv;
1847 
1848 	if (f->tuner)
1849 		return -EINVAL;
1850 
1851 	bttv_set_frequency(btv, f);
1852 	return 0;
1853 }
1854 
1855 static int bttv_log_status(struct file *file, void *f)
1856 {
1857 	struct video_device *vdev = video_devdata(file);
1858 	struct bttv_fh *fh  = f;
1859 	struct bttv *btv = fh->btv;
1860 
1861 	v4l2_ctrl_handler_log_status(vdev->ctrl_handler, btv->c.v4l2_dev.name);
1862 	bttv_call_all(btv, core, log_status);
1863 	return 0;
1864 }
1865 
1866 #ifdef CONFIG_VIDEO_ADV_DEBUG
1867 static int bttv_g_register(struct file *file, void *f,
1868 					struct v4l2_dbg_register *reg)
1869 {
1870 	struct bttv_fh *fh = f;
1871 	struct bttv *btv = fh->btv;
1872 
1873 	/* bt848 has a 12-bit register space */
1874 	reg->reg &= 0xfff;
1875 	reg->val = btread(reg->reg);
1876 	reg->size = 1;
1877 
1878 	return 0;
1879 }
1880 
1881 static int bttv_s_register(struct file *file, void *f,
1882 					const struct v4l2_dbg_register *reg)
1883 {
1884 	struct bttv_fh *fh = f;
1885 	struct bttv *btv = fh->btv;
1886 
1887 	/* bt848 has a 12-bit register space */
1888 	btwrite(reg->val, reg->reg & 0xfff);
1889 
1890 	return 0;
1891 }
1892 #endif
1893 
1894 /* Given cropping boundaries b and the scaled width and height of a
1895    single field or frame, which must not exceed hardware limits, this
1896    function adjusts the cropping parameters c. */
1897 static void
1898 bttv_crop_adjust	(struct bttv_crop *             c,
1899 			 const struct v4l2_rect *	b,
1900 			 __s32                          width,
1901 			 __s32                          height,
1902 			 enum v4l2_field                field)
1903 {
1904 	__s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
1905 	__s32 max_left;
1906 	__s32 max_top;
1907 
1908 	if (width < c->min_scaled_width) {
1909 		/* Max. hor. scale factor 16:1. */
1910 		c->rect.width = width * 16;
1911 	} else if (width > c->max_scaled_width) {
1912 		/* Min. hor. scale factor 1:1. */
1913 		c->rect.width = width;
1914 
1915 		max_left = b->left + b->width - width;
1916 		max_left = min(max_left, (__s32) MAX_HDELAY);
1917 		if (c->rect.left > max_left)
1918 			c->rect.left = max_left;
1919 	}
1920 
1921 	if (height < c->min_scaled_height) {
1922 		/* Max. vert. scale factor 16:1, single fields 8:1. */
1923 		c->rect.height = height * 16;
1924 	} else if (frame_height > c->max_scaled_height) {
1925 		/* Min. vert. scale factor 1:1.
1926 		   Top and height count field lines times two. */
1927 		c->rect.height = (frame_height + 1) & ~1;
1928 
1929 		max_top = b->top + b->height - c->rect.height;
1930 		if (c->rect.top > max_top)
1931 			c->rect.top = max_top;
1932 	}
1933 
1934 	bttv_crop_calc_limits(c);
1935 }
1936 
1937 /* Returns an error if scaling to a frame or single field with the given
1938    width and height is not possible with the current cropping parameters
1939    and width aligned according to width_mask. If adjust_size is TRUE the
1940    function may adjust the width and/or height instead, rounding width
1941    to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
1942    also adjust the current cropping parameters to get closer to the
1943    desired image size. */
1944 static int
1945 limit_scaled_size_lock       (struct bttv_fh *               fh,
1946 			 __s32 *                        width,
1947 			 __s32 *                        height,
1948 			 enum v4l2_field                field,
1949 			 unsigned int			width_mask,
1950 			 unsigned int			width_bias,
1951 			 int                            adjust_size,
1952 			 int                            adjust_crop)
1953 {
1954 	struct bttv *btv = fh->btv;
1955 	const struct v4l2_rect *b;
1956 	struct bttv_crop *c;
1957 	__s32 min_width;
1958 	__s32 min_height;
1959 	__s32 max_width;
1960 	__s32 max_height;
1961 	int rc;
1962 
1963 	BUG_ON((int) width_mask >= 0 ||
1964 	       width_bias >= (unsigned int) -width_mask);
1965 
1966 	/* Make sure tvnorm, vbi_end and the current cropping parameters
1967 	   remain consistent until we're done. */
1968 
1969 	b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
1970 
1971 	/* Do crop - use current, don't - use default parameters. */
1972 	c = &btv->crop[!!fh->do_crop];
1973 
1974 	if (fh->do_crop
1975 	    && adjust_size
1976 	    && adjust_crop
1977 	    && !locked_btres(btv, VIDEO_RESOURCES)) {
1978 		min_width = 48;
1979 		min_height = 32;
1980 
1981 		/* We cannot scale up. When the scaled image is larger
1982 		   than crop.rect we adjust the crop.rect as required
1983 		   by the V4L2 spec, hence cropcap.bounds are our limit. */
1984 		max_width = min_t(unsigned int, b->width, MAX_HACTIVE);
1985 		max_height = b->height;
1986 
1987 		/* We cannot capture the same line as video and VBI data.
1988 		   Note btv->vbi_end is really a minimum, see
1989 		   bttv_vbi_try_fmt(). */
1990 		if (btv->vbi_end > b->top) {
1991 			max_height -= btv->vbi_end - b->top;
1992 			rc = -EBUSY;
1993 			if (min_height > max_height)
1994 				goto fail;
1995 		}
1996 	} else {
1997 		rc = -EBUSY;
1998 		if (btv->vbi_end > c->rect.top)
1999 			goto fail;
2000 
2001 		min_width  = c->min_scaled_width;
2002 		min_height = c->min_scaled_height;
2003 		max_width  = c->max_scaled_width;
2004 		max_height = c->max_scaled_height;
2005 
2006 		adjust_crop = 0;
2007 	}
2008 
2009 	min_width = (min_width - width_mask - 1) & width_mask;
2010 	max_width = max_width & width_mask;
2011 
2012 	/* Max. scale factor is 16:1 for frames, 8:1 for fields. */
2013 	/* Min. scale factor is 1:1. */
2014 	max_height >>= !V4L2_FIELD_HAS_BOTH(field);
2015 
2016 	if (adjust_size) {
2017 		*width = clamp(*width, min_width, max_width);
2018 		*height = clamp(*height, min_height, max_height);
2019 
2020 		/* Round after clamping to avoid overflow. */
2021 		*width = (*width + width_bias) & width_mask;
2022 
2023 		if (adjust_crop) {
2024 			bttv_crop_adjust(c, b, *width, *height, field);
2025 
2026 			if (btv->vbi_end > c->rect.top) {
2027 				/* Move the crop window out of the way. */
2028 				c->rect.top = btv->vbi_end;
2029 			}
2030 		}
2031 	} else {
2032 		rc = -EINVAL;
2033 		if (*width  < min_width ||
2034 		    *height < min_height ||
2035 		    *width  > max_width ||
2036 		    *height > max_height ||
2037 		    0 != (*width & ~width_mask))
2038 			goto fail;
2039 	}
2040 
2041 	rc = 0; /* success */
2042 
2043  fail:
2044 
2045 	return rc;
2046 }
2047 
2048 /* Returns an error if the given overlay window dimensions are not
2049    possible with the current cropping parameters. If adjust_size is
2050    TRUE the function may adjust the window width and/or height
2051    instead, however it always rounds the horizontal position and
2052    width as btcx_align() does. If adjust_crop is TRUE the function
2053    may also adjust the current cropping parameters to get closer
2054    to the desired window size. */
2055 static int
2056 verify_window_lock(struct bttv_fh *fh, struct v4l2_window *win,
2057 			 int adjust_size, int adjust_crop)
2058 {
2059 	enum v4l2_field field;
2060 	unsigned int width_mask;
2061 	int rc;
2062 
2063 	if (win->w.width < 48)
2064 		win->w.width = 48;
2065 	if (win->w.height < 32)
2066 		win->w.height = 32;
2067 	if (win->clipcount > 2048)
2068 		win->clipcount = 2048;
2069 
2070 	win->chromakey = 0;
2071 	win->global_alpha = 0;
2072 	field = win->field;
2073 
2074 	switch (field) {
2075 	case V4L2_FIELD_TOP:
2076 	case V4L2_FIELD_BOTTOM:
2077 	case V4L2_FIELD_INTERLACED:
2078 		break;
2079 	default:
2080 		field = V4L2_FIELD_ANY;
2081 		break;
2082 	}
2083 	if (V4L2_FIELD_ANY == field) {
2084 		__s32 height2;
2085 
2086 		height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2087 		field = (win->w.height > height2)
2088 			? V4L2_FIELD_INTERLACED
2089 			: V4L2_FIELD_TOP;
2090 	}
2091 	win->field = field;
2092 
2093 	if (NULL == fh->ovfmt)
2094 		return -EINVAL;
2095 	/* 4-byte alignment. */
2096 	width_mask = ~0;
2097 	switch (fh->ovfmt->depth) {
2098 	case 8:
2099 	case 24:
2100 		width_mask = ~3;
2101 		break;
2102 	case 16:
2103 		width_mask = ~1;
2104 		break;
2105 	case 32:
2106 		break;
2107 	default:
2108 		BUG();
2109 	}
2110 
2111 	win->w.width -= win->w.left & ~width_mask;
2112 	win->w.left = (win->w.left - width_mask - 1) & width_mask;
2113 
2114 	rc = limit_scaled_size_lock(fh, &win->w.width, &win->w.height,
2115 			       field, width_mask,
2116 			       /* width_bias: round down */ 0,
2117 			       adjust_size, adjust_crop);
2118 	if (0 != rc)
2119 		return rc;
2120 	return 0;
2121 }
2122 
2123 static int setup_window_lock(struct bttv_fh *fh, struct bttv *btv,
2124 			struct v4l2_window *win, int fixup)
2125 {
2126 	struct v4l2_clip *clips = NULL;
2127 	int n,size,retval = 0;
2128 
2129 	if (NULL == fh->ovfmt)
2130 		return -EINVAL;
2131 	if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2132 		return -EINVAL;
2133 	retval = verify_window_lock(fh, win,
2134 			       /* adjust_size */ fixup,
2135 			       /* adjust_crop */ fixup);
2136 	if (0 != retval)
2137 		return retval;
2138 
2139 	/* copy clips  --  luckily v4l1 + v4l2 are binary
2140 	   compatible here ...*/
2141 	n = win->clipcount;
2142 	size = sizeof(*clips)*(n+4);
2143 	clips = kmalloc(size,GFP_KERNEL);
2144 	if (NULL == clips)
2145 		return -ENOMEM;
2146 	if (n > 0) {
2147 		if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2148 			kfree(clips);
2149 			return -EFAULT;
2150 		}
2151 	}
2152 
2153 	/* clip against screen */
2154 	if (NULL != btv->fbuf.base)
2155 		n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2156 				      &win->w, clips, n);
2157 	btcx_sort_clips(clips,n);
2158 
2159 	/* 4-byte alignments */
2160 	switch (fh->ovfmt->depth) {
2161 	case 8:
2162 	case 24:
2163 		btcx_align(&win->w, clips, n, 3);
2164 		break;
2165 	case 16:
2166 		btcx_align(&win->w, clips, n, 1);
2167 		break;
2168 	case 32:
2169 		/* no alignment fixups needed */
2170 		break;
2171 	default:
2172 		BUG();
2173 	}
2174 
2175 	kfree(fh->ov.clips);
2176 	fh->ov.clips    = clips;
2177 	fh->ov.nclips   = n;
2178 
2179 	fh->ov.w        = win->w;
2180 	fh->ov.field    = win->field;
2181 	fh->ov.setup_ok = 1;
2182 
2183 	btv->init.ov.w.width   = win->w.width;
2184 	btv->init.ov.w.height  = win->w.height;
2185 	btv->init.ov.field     = win->field;
2186 
2187 	/* update overlay if needed */
2188 	retval = 0;
2189 	if (check_btres(fh, RESOURCE_OVERLAY)) {
2190 		struct bttv_buffer *new;
2191 
2192 		new = videobuf_sg_alloc(sizeof(*new));
2193 		new->crop = btv->crop[!!fh->do_crop].rect;
2194 		bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2195 		retval = bttv_switch_overlay(btv,fh,new);
2196 	}
2197 	return retval;
2198 }
2199 
2200 /* ----------------------------------------------------------------------- */
2201 
2202 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2203 {
2204 	struct videobuf_queue* q = NULL;
2205 
2206 	switch (fh->type) {
2207 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2208 		q = &fh->cap;
2209 		break;
2210 	case V4L2_BUF_TYPE_VBI_CAPTURE:
2211 		q = &fh->vbi;
2212 		break;
2213 	default:
2214 		BUG();
2215 	}
2216 	return q;
2217 }
2218 
2219 static int bttv_resource(struct bttv_fh *fh)
2220 {
2221 	int res = 0;
2222 
2223 	switch (fh->type) {
2224 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2225 		res = RESOURCE_VIDEO_STREAM;
2226 		break;
2227 	case V4L2_BUF_TYPE_VBI_CAPTURE:
2228 		res = RESOURCE_VBI;
2229 		break;
2230 	default:
2231 		BUG();
2232 	}
2233 	return res;
2234 }
2235 
2236 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2237 {
2238 	struct videobuf_queue *q = bttv_queue(fh);
2239 	int res = bttv_resource(fh);
2240 
2241 	if (check_btres(fh,res))
2242 		return -EBUSY;
2243 	if (videobuf_queue_is_busy(q))
2244 		return -EBUSY;
2245 	fh->type = type;
2246 	return 0;
2247 }
2248 
2249 static void
2250 pix_format_set_size     (struct v4l2_pix_format *       f,
2251 			 const struct bttv_format *     fmt,
2252 			 unsigned int                   width,
2253 			 unsigned int                   height)
2254 {
2255 	f->width = width;
2256 	f->height = height;
2257 
2258 	if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2259 		f->bytesperline = width; /* Y plane */
2260 		f->sizeimage = (width * height * fmt->depth) >> 3;
2261 	} else {
2262 		f->bytesperline = (width * fmt->depth) >> 3;
2263 		f->sizeimage = height * f->bytesperline;
2264 	}
2265 }
2266 
2267 static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
2268 					struct v4l2_format *f)
2269 {
2270 	struct bttv_fh *fh  = priv;
2271 
2272 	pix_format_set_size(&f->fmt.pix, fh->fmt,
2273 				fh->width, fh->height);
2274 	f->fmt.pix.field        = fh->cap.field;
2275 	f->fmt.pix.pixelformat  = fh->fmt->fourcc;
2276 	f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
2277 
2278 	return 0;
2279 }
2280 
2281 static int bttv_g_fmt_vid_overlay(struct file *file, void *priv,
2282 					struct v4l2_format *f)
2283 {
2284 	struct bttv_fh *fh  = priv;
2285 
2286 	f->fmt.win.w     = fh->ov.w;
2287 	f->fmt.win.field = fh->ov.field;
2288 
2289 	return 0;
2290 }
2291 
2292 static void bttv_get_width_mask_vid_cap(const struct bttv_format *fmt,
2293 					unsigned int *width_mask,
2294 					unsigned int *width_bias)
2295 {
2296 	if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2297 		*width_mask = ~15; /* width must be a multiple of 16 pixels */
2298 		*width_bias = 8;   /* nearest */
2299 	} else {
2300 		*width_mask = ~3; /* width must be a multiple of 4 pixels */
2301 		*width_bias = 2;  /* nearest */
2302 	}
2303 }
2304 
2305 static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
2306 						struct v4l2_format *f)
2307 {
2308 	const struct bttv_format *fmt;
2309 	struct bttv_fh *fh = priv;
2310 	struct bttv *btv = fh->btv;
2311 	enum v4l2_field field;
2312 	__s32 width, height;
2313 	__s32 height2;
2314 	unsigned int width_mask, width_bias;
2315 	int rc;
2316 
2317 	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2318 	if (NULL == fmt)
2319 		return -EINVAL;
2320 
2321 	field = f->fmt.pix.field;
2322 
2323 	switch (field) {
2324 	case V4L2_FIELD_TOP:
2325 	case V4L2_FIELD_BOTTOM:
2326 	case V4L2_FIELD_ALTERNATE:
2327 	case V4L2_FIELD_INTERLACED:
2328 		break;
2329 	case V4L2_FIELD_SEQ_BT:
2330 	case V4L2_FIELD_SEQ_TB:
2331 		if (!(fmt->flags & FORMAT_FLAGS_PLANAR)) {
2332 			field = V4L2_FIELD_SEQ_TB;
2333 			break;
2334 		}
2335 		/* fall through */
2336 	default: /* FIELD_ANY case */
2337 		height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2338 		field = (f->fmt.pix.height > height2)
2339 			? V4L2_FIELD_INTERLACED
2340 			: V4L2_FIELD_BOTTOM;
2341 		break;
2342 	}
2343 
2344 	width = f->fmt.pix.width;
2345 	height = f->fmt.pix.height;
2346 
2347 	bttv_get_width_mask_vid_cap(fmt, &width_mask, &width_bias);
2348 	rc = limit_scaled_size_lock(fh, &width, &height, field,
2349 			       width_mask, width_bias,
2350 			       /* adjust_size */ 1,
2351 			       /* adjust_crop */ 0);
2352 	if (0 != rc)
2353 		return rc;
2354 
2355 	/* update data for the application */
2356 	f->fmt.pix.field = field;
2357 	pix_format_set_size(&f->fmt.pix, fmt, width, height);
2358 	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
2359 
2360 	return 0;
2361 }
2362 
2363 static int bttv_try_fmt_vid_overlay(struct file *file, void *priv,
2364 						struct v4l2_format *f)
2365 {
2366 	struct bttv_fh *fh = priv;
2367 
2368 	verify_window_lock(fh, &f->fmt.win,
2369 			/* adjust_size */ 1,
2370 			/* adjust_crop */ 0);
2371 	return 0;
2372 }
2373 
2374 static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2375 				struct v4l2_format *f)
2376 {
2377 	int retval;
2378 	const struct bttv_format *fmt;
2379 	struct bttv_fh *fh = priv;
2380 	struct bttv *btv = fh->btv;
2381 	__s32 width, height;
2382 	unsigned int width_mask, width_bias;
2383 	enum v4l2_field field;
2384 
2385 	retval = bttv_switch_type(fh, f->type);
2386 	if (0 != retval)
2387 		return retval;
2388 
2389 	retval = bttv_try_fmt_vid_cap(file, priv, f);
2390 	if (0 != retval)
2391 		return retval;
2392 
2393 	width = f->fmt.pix.width;
2394 	height = f->fmt.pix.height;
2395 	field = f->fmt.pix.field;
2396 
2397 	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2398 	bttv_get_width_mask_vid_cap(fmt, &width_mask, &width_bias);
2399 	retval = limit_scaled_size_lock(fh, &width, &height, f->fmt.pix.field,
2400 			       width_mask, width_bias,
2401 			       /* adjust_size */ 1,
2402 			       /* adjust_crop */ 1);
2403 	if (0 != retval)
2404 		return retval;
2405 
2406 	f->fmt.pix.field = field;
2407 
2408 	/* update our state information */
2409 	fh->fmt              = fmt;
2410 	fh->cap.field        = f->fmt.pix.field;
2411 	fh->cap.last         = V4L2_FIELD_NONE;
2412 	fh->width            = f->fmt.pix.width;
2413 	fh->height           = f->fmt.pix.height;
2414 	btv->init.fmt        = fmt;
2415 	btv->init.width      = f->fmt.pix.width;
2416 	btv->init.height     = f->fmt.pix.height;
2417 
2418 	return 0;
2419 }
2420 
2421 static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
2422 				struct v4l2_format *f)
2423 {
2424 	struct bttv_fh *fh = priv;
2425 	struct bttv *btv = fh->btv;
2426 
2427 	if (no_overlay > 0) {
2428 		pr_err("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2429 		return -EINVAL;
2430 	}
2431 
2432 	return setup_window_lock(fh, btv, &f->fmt.win, 1);
2433 }
2434 
2435 static int bttv_querycap(struct file *file, void  *priv,
2436 				struct v4l2_capability *cap)
2437 {
2438 	struct bttv_fh *fh = priv;
2439 	struct bttv *btv = fh->btv;
2440 
2441 	if (0 == v4l2)
2442 		return -EINVAL;
2443 
2444 	strscpy(cap->driver, "bttv", sizeof(cap->driver));
2445 	strscpy(cap->card, btv->video_dev.name, sizeof(cap->card));
2446 	snprintf(cap->bus_info, sizeof(cap->bus_info),
2447 		 "PCI:%s", pci_name(btv->c.pci));
2448 	cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
2449 			    V4L2_CAP_STREAMING | V4L2_CAP_DEVICE_CAPS;
2450 	if (no_overlay <= 0)
2451 		cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2452 	if (video_is_registered(&btv->vbi_dev))
2453 		cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
2454 	if (video_is_registered(&btv->radio_dev)) {
2455 		cap->capabilities |= V4L2_CAP_RADIO;
2456 		if (btv->has_tea575x)
2457 			cap->capabilities |= V4L2_CAP_HW_FREQ_SEEK;
2458 	}
2459 
2460 	/*
2461 	 * No need to lock here: those vars are initialized during board
2462 	 * probe and remains untouched during the rest of the driver lifecycle
2463 	 */
2464 	if (btv->has_saa6588)
2465 		cap->capabilities |= V4L2_CAP_RDS_CAPTURE;
2466 	if (btv->tuner_type != TUNER_ABSENT)
2467 		cap->capabilities |= V4L2_CAP_TUNER;
2468 	return 0;
2469 }
2470 
2471 static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f)
2472 {
2473 	int index = -1, i;
2474 
2475 	for (i = 0; i < FORMATS; i++) {
2476 		if (formats[i].fourcc != -1)
2477 			index++;
2478 		if ((unsigned int)index == f->index)
2479 			break;
2480 	}
2481 	if (FORMATS == i)
2482 		return -EINVAL;
2483 
2484 	f->pixelformat = formats[i].fourcc;
2485 
2486 	return i;
2487 }
2488 
2489 static int bttv_enum_fmt_vid_cap(struct file *file, void  *priv,
2490 				struct v4l2_fmtdesc *f)
2491 {
2492 	int rc = bttv_enum_fmt_cap_ovr(f);
2493 
2494 	if (rc < 0)
2495 		return rc;
2496 
2497 	return 0;
2498 }
2499 
2500 static int bttv_enum_fmt_vid_overlay(struct file *file, void  *priv,
2501 					struct v4l2_fmtdesc *f)
2502 {
2503 	int rc;
2504 
2505 	if (no_overlay > 0) {
2506 		pr_err("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2507 		return -EINVAL;
2508 	}
2509 
2510 	rc = bttv_enum_fmt_cap_ovr(f);
2511 
2512 	if (rc < 0)
2513 		return rc;
2514 
2515 	if (!(formats[rc].flags & FORMAT_FLAGS_PACKED))
2516 		return -EINVAL;
2517 
2518 	return 0;
2519 }
2520 
2521 static int bttv_g_fbuf(struct file *file, void *f,
2522 				struct v4l2_framebuffer *fb)
2523 {
2524 	struct bttv_fh *fh = f;
2525 	struct bttv *btv = fh->btv;
2526 
2527 	*fb = btv->fbuf;
2528 	fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2529 	fb->flags = V4L2_FBUF_FLAG_PRIMARY;
2530 	if (fh->ovfmt)
2531 		fb->fmt.pixelformat  = fh->ovfmt->fourcc;
2532 	return 0;
2533 }
2534 
2535 static int bttv_overlay(struct file *file, void *f, unsigned int on)
2536 {
2537 	struct bttv_fh *fh = f;
2538 	struct bttv *btv = fh->btv;
2539 	struct bttv_buffer *new;
2540 	int retval = 0;
2541 
2542 	if (on) {
2543 		/* verify args */
2544 		if (unlikely(!btv->fbuf.base)) {
2545 			return -EINVAL;
2546 		}
2547 		if (unlikely(!fh->ov.setup_ok)) {
2548 			dprintk("%d: overlay: !setup_ok\n", btv->c.nr);
2549 			retval = -EINVAL;
2550 		}
2551 		if (retval)
2552 			return retval;
2553 	}
2554 
2555 	if (!check_alloc_btres_lock(btv, fh, RESOURCE_OVERLAY))
2556 		return -EBUSY;
2557 
2558 	if (on) {
2559 		fh->ov.tvnorm = btv->tvnorm;
2560 		new = videobuf_sg_alloc(sizeof(*new));
2561 		new->crop = btv->crop[!!fh->do_crop].rect;
2562 		bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2563 	} else {
2564 		new = NULL;
2565 	}
2566 
2567 	/* switch over */
2568 	retval = bttv_switch_overlay(btv, fh, new);
2569 	return retval;
2570 }
2571 
2572 static int bttv_s_fbuf(struct file *file, void *f,
2573 				const struct v4l2_framebuffer *fb)
2574 {
2575 	struct bttv_fh *fh = f;
2576 	struct bttv *btv = fh->btv;
2577 	const struct bttv_format *fmt;
2578 	int retval;
2579 
2580 	if (!capable(CAP_SYS_ADMIN) &&
2581 		!capable(CAP_SYS_RAWIO))
2582 		return -EPERM;
2583 
2584 	/* check args */
2585 	fmt = format_by_fourcc(fb->fmt.pixelformat);
2586 	if (NULL == fmt)
2587 		return -EINVAL;
2588 	if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2589 		return -EINVAL;
2590 
2591 	retval = -EINVAL;
2592 	if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2593 		__s32 width = fb->fmt.width;
2594 		__s32 height = fb->fmt.height;
2595 
2596 		retval = limit_scaled_size_lock(fh, &width, &height,
2597 					   V4L2_FIELD_INTERLACED,
2598 					   /* width_mask */ ~3,
2599 					   /* width_bias */ 2,
2600 					   /* adjust_size */ 0,
2601 					   /* adjust_crop */ 0);
2602 		if (0 != retval)
2603 			return retval;
2604 	}
2605 
2606 	/* ok, accept it */
2607 	btv->fbuf.base       = fb->base;
2608 	btv->fbuf.fmt.width  = fb->fmt.width;
2609 	btv->fbuf.fmt.height = fb->fmt.height;
2610 	if (0 != fb->fmt.bytesperline)
2611 		btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2612 	else
2613 		btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2614 
2615 	retval = 0;
2616 	fh->ovfmt = fmt;
2617 	btv->init.ovfmt = fmt;
2618 	if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2619 		fh->ov.w.left   = 0;
2620 		fh->ov.w.top    = 0;
2621 		fh->ov.w.width  = fb->fmt.width;
2622 		fh->ov.w.height = fb->fmt.height;
2623 		btv->init.ov.w.width  = fb->fmt.width;
2624 		btv->init.ov.w.height = fb->fmt.height;
2625 
2626 		kfree(fh->ov.clips);
2627 		fh->ov.clips = NULL;
2628 		fh->ov.nclips = 0;
2629 
2630 		if (check_btres(fh, RESOURCE_OVERLAY)) {
2631 			struct bttv_buffer *new;
2632 
2633 			new = videobuf_sg_alloc(sizeof(*new));
2634 			new->crop = btv->crop[!!fh->do_crop].rect;
2635 			bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2636 			retval = bttv_switch_overlay(btv, fh, new);
2637 		}
2638 	}
2639 	return retval;
2640 }
2641 
2642 static int bttv_reqbufs(struct file *file, void *priv,
2643 				struct v4l2_requestbuffers *p)
2644 {
2645 	struct bttv_fh *fh = priv;
2646 	return videobuf_reqbufs(bttv_queue(fh), p);
2647 }
2648 
2649 static int bttv_querybuf(struct file *file, void *priv,
2650 				struct v4l2_buffer *b)
2651 {
2652 	struct bttv_fh *fh = priv;
2653 	return videobuf_querybuf(bttv_queue(fh), b);
2654 }
2655 
2656 static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2657 {
2658 	struct bttv_fh *fh = priv;
2659 	struct bttv *btv = fh->btv;
2660 	int res = bttv_resource(fh);
2661 
2662 	if (!check_alloc_btres_lock(btv, fh, res))
2663 		return -EBUSY;
2664 
2665 	return videobuf_qbuf(bttv_queue(fh), b);
2666 }
2667 
2668 static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2669 {
2670 	struct bttv_fh *fh = priv;
2671 	return videobuf_dqbuf(bttv_queue(fh), b,
2672 			file->f_flags & O_NONBLOCK);
2673 }
2674 
2675 static int bttv_streamon(struct file *file, void *priv,
2676 					enum v4l2_buf_type type)
2677 {
2678 	struct bttv_fh *fh = priv;
2679 	struct bttv *btv = fh->btv;
2680 	int res = bttv_resource(fh);
2681 
2682 	if (!check_alloc_btres_lock(btv, fh, res))
2683 		return -EBUSY;
2684 	return videobuf_streamon(bttv_queue(fh));
2685 }
2686 
2687 
2688 static int bttv_streamoff(struct file *file, void *priv,
2689 					enum v4l2_buf_type type)
2690 {
2691 	struct bttv_fh *fh = priv;
2692 	struct bttv *btv = fh->btv;
2693 	int retval;
2694 	int res = bttv_resource(fh);
2695 
2696 
2697 	retval = videobuf_streamoff(bttv_queue(fh));
2698 	if (retval < 0)
2699 		return retval;
2700 	free_btres_lock(btv, fh, res);
2701 	return 0;
2702 }
2703 
2704 static int bttv_g_parm(struct file *file, void *f,
2705 				struct v4l2_streamparm *parm)
2706 {
2707 	struct bttv_fh *fh = f;
2708 	struct bttv *btv = fh->btv;
2709 
2710 	if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2711 		return -EINVAL;
2712 	parm->parm.capture.readbuffers = gbuffers;
2713 	v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id,
2714 				    &parm->parm.capture.timeperframe);
2715 
2716 	return 0;
2717 }
2718 
2719 static int bttv_g_tuner(struct file *file, void *priv,
2720 				struct v4l2_tuner *t)
2721 {
2722 	struct bttv_fh *fh = priv;
2723 	struct bttv *btv = fh->btv;
2724 
2725 	if (0 != t->index)
2726 		return -EINVAL;
2727 
2728 	t->rxsubchans = V4L2_TUNER_SUB_MONO;
2729 	t->capability = V4L2_TUNER_CAP_NORM;
2730 	bttv_call_all(btv, tuner, g_tuner, t);
2731 	strscpy(t->name, "Television", sizeof(t->name));
2732 	t->type       = V4L2_TUNER_ANALOG_TV;
2733 	if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2734 		t->signal = 0xffff;
2735 
2736 	if (btv->audio_mode_gpio)
2737 		btv->audio_mode_gpio(btv, t, 0);
2738 
2739 	return 0;
2740 }
2741 
2742 static int bttv_g_pixelaspect(struct file *file, void *priv,
2743 			      int type, struct v4l2_fract *f)
2744 {
2745 	struct bttv_fh *fh = priv;
2746 	struct bttv *btv = fh->btv;
2747 
2748 	if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2749 		return -EINVAL;
2750 
2751 	/* defrect and bounds are set via g_selection */
2752 	*f = bttv_tvnorms[btv->tvnorm].cropcap.pixelaspect;
2753 	return 0;
2754 }
2755 
2756 static int bttv_g_selection(struct file *file, void *f, struct v4l2_selection *sel)
2757 {
2758 	struct bttv_fh *fh = f;
2759 	struct bttv *btv = fh->btv;
2760 
2761 	if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2762 	    sel->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2763 		return -EINVAL;
2764 
2765 	switch (sel->target) {
2766 	case V4L2_SEL_TGT_CROP:
2767 		/*
2768 		 * No fh->do_crop = 1; because btv->crop[1] may be
2769 		 * inconsistent with fh->width or fh->height and apps
2770 		 * do not expect a change here.
2771 		 */
2772 		sel->r = btv->crop[!!fh->do_crop].rect;
2773 		break;
2774 	case V4L2_SEL_TGT_CROP_DEFAULT:
2775 		sel->r = bttv_tvnorms[btv->tvnorm].cropcap.defrect;
2776 		break;
2777 	case V4L2_SEL_TGT_CROP_BOUNDS:
2778 		sel->r = bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2779 		break;
2780 	default:
2781 		return -EINVAL;
2782 	}
2783 
2784 	return 0;
2785 }
2786 
2787 static int bttv_s_selection(struct file *file, void *f, struct v4l2_selection *sel)
2788 {
2789 	struct bttv_fh *fh = f;
2790 	struct bttv *btv = fh->btv;
2791 	const struct v4l2_rect *b;
2792 	int retval;
2793 	struct bttv_crop c;
2794 	__s32 b_left;
2795 	__s32 b_top;
2796 	__s32 b_right;
2797 	__s32 b_bottom;
2798 
2799 	if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2800 	    sel->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2801 		return -EINVAL;
2802 
2803 	if (sel->target != V4L2_SEL_TGT_CROP)
2804 		return -EINVAL;
2805 
2806 	/* Make sure tvnorm, vbi_end and the current cropping
2807 	   parameters remain consistent until we're done. Note
2808 	   read() may change vbi_end in check_alloc_btres_lock(). */
2809 	retval = -EBUSY;
2810 
2811 	if (locked_btres(fh->btv, VIDEO_RESOURCES)) {
2812 		return retval;
2813 	}
2814 
2815 	b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2816 
2817 	b_left = b->left;
2818 	b_right = b_left + b->width;
2819 	b_bottom = b->top + b->height;
2820 
2821 	b_top = max(b->top, btv->vbi_end);
2822 	if (b_top + 32 >= b_bottom) {
2823 		return retval;
2824 	}
2825 
2826 	/* Min. scaled size 48 x 32. */
2827 	c.rect.left = clamp_t(s32, sel->r.left, b_left, b_right - 48);
2828 	c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
2829 
2830 	c.rect.width = clamp_t(s32, sel->r.width,
2831 			     48, b_right - c.rect.left);
2832 
2833 	c.rect.top = clamp_t(s32, sel->r.top, b_top, b_bottom - 32);
2834 	/* Top and height must be a multiple of two. */
2835 	c.rect.top = (c.rect.top + 1) & ~1;
2836 
2837 	c.rect.height = clamp_t(s32, sel->r.height,
2838 			      32, b_bottom - c.rect.top);
2839 	c.rect.height = (c.rect.height + 1) & ~1;
2840 
2841 	bttv_crop_calc_limits(&c);
2842 
2843 	sel->r = c.rect;
2844 
2845 	btv->crop[1] = c;
2846 
2847 	fh->do_crop = 1;
2848 
2849 	if (fh->width < c.min_scaled_width) {
2850 		fh->width = c.min_scaled_width;
2851 		btv->init.width = c.min_scaled_width;
2852 	} else if (fh->width > c.max_scaled_width) {
2853 		fh->width = c.max_scaled_width;
2854 		btv->init.width = c.max_scaled_width;
2855 	}
2856 
2857 	if (fh->height < c.min_scaled_height) {
2858 		fh->height = c.min_scaled_height;
2859 		btv->init.height = c.min_scaled_height;
2860 	} else if (fh->height > c.max_scaled_height) {
2861 		fh->height = c.max_scaled_height;
2862 		btv->init.height = c.max_scaled_height;
2863 	}
2864 
2865 	return 0;
2866 }
2867 
2868 static ssize_t bttv_read(struct file *file, char __user *data,
2869 			 size_t count, loff_t *ppos)
2870 {
2871 	struct bttv_fh *fh = file->private_data;
2872 	int retval = 0;
2873 
2874 	if (fh->btv->errors)
2875 		bttv_reinit_bt848(fh->btv);
2876 	dprintk("%d: read count=%d type=%s\n",
2877 		fh->btv->c.nr, (int)count, v4l2_type_names[fh->type]);
2878 
2879 	switch (fh->type) {
2880 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2881 		if (!check_alloc_btres_lock(fh->btv, fh, RESOURCE_VIDEO_READ)) {
2882 			/* VIDEO_READ in use by another fh,
2883 			   or VIDEO_STREAM by any fh. */
2884 			return -EBUSY;
2885 		}
2886 		retval = videobuf_read_one(&fh->cap, data, count, ppos,
2887 					   file->f_flags & O_NONBLOCK);
2888 		free_btres_lock(fh->btv, fh, RESOURCE_VIDEO_READ);
2889 		break;
2890 	case V4L2_BUF_TYPE_VBI_CAPTURE:
2891 		if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI))
2892 			return -EBUSY;
2893 		retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
2894 					      file->f_flags & O_NONBLOCK);
2895 		break;
2896 	default:
2897 		BUG();
2898 	}
2899 	return retval;
2900 }
2901 
2902 static __poll_t bttv_poll(struct file *file, poll_table *wait)
2903 {
2904 	struct bttv_fh *fh = file->private_data;
2905 	struct bttv_buffer *buf;
2906 	enum v4l2_field field;
2907 	__poll_t rc = 0;
2908 	__poll_t req_events = poll_requested_events(wait);
2909 
2910 	if (v4l2_event_pending(&fh->fh))
2911 		rc = EPOLLPRI;
2912 	else if (req_events & EPOLLPRI)
2913 		poll_wait(file, &fh->fh.wait, wait);
2914 
2915 	if (!(req_events & (EPOLLIN | EPOLLRDNORM)))
2916 		return rc;
2917 
2918 	if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
2919 		if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI))
2920 			return rc | EPOLLERR;
2921 		return rc | videobuf_poll_stream(file, &fh->vbi, wait);
2922 	}
2923 
2924 	if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
2925 		/* streaming capture */
2926 		if (list_empty(&fh->cap.stream))
2927 			return rc | EPOLLERR;
2928 		buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
2929 	} else {
2930 		/* read() capture */
2931 		if (NULL == fh->cap.read_buf) {
2932 			/* need to capture a new frame */
2933 			if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
2934 				return rc | EPOLLERR;
2935 			fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize);
2936 			if (NULL == fh->cap.read_buf)
2937 				return rc | EPOLLERR;
2938 			fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
2939 			field = videobuf_next_field(&fh->cap);
2940 			if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
2941 				kfree (fh->cap.read_buf);
2942 				fh->cap.read_buf = NULL;
2943 				return rc | EPOLLERR;
2944 			}
2945 			fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
2946 			fh->cap.read_off = 0;
2947 		}
2948 		buf = (struct bttv_buffer*)fh->cap.read_buf;
2949 	}
2950 
2951 	poll_wait(file, &buf->vb.done, wait);
2952 	if (buf->vb.state == VIDEOBUF_DONE ||
2953 	    buf->vb.state == VIDEOBUF_ERROR)
2954 		rc = rc | EPOLLIN|EPOLLRDNORM;
2955 	return rc;
2956 }
2957 
2958 static int bttv_open(struct file *file)
2959 {
2960 	struct video_device *vdev = video_devdata(file);
2961 	struct bttv *btv = video_drvdata(file);
2962 	struct bttv_fh *fh;
2963 	enum v4l2_buf_type type = 0;
2964 
2965 	dprintk("open dev=%s\n", video_device_node_name(vdev));
2966 
2967 	if (vdev->vfl_type == VFL_TYPE_VIDEO) {
2968 		type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2969 	} else if (vdev->vfl_type == VFL_TYPE_VBI) {
2970 		type = V4L2_BUF_TYPE_VBI_CAPTURE;
2971 	} else {
2972 		WARN_ON(1);
2973 		return -ENODEV;
2974 	}
2975 
2976 	dprintk("%d: open called (type=%s)\n",
2977 		btv->c.nr, v4l2_type_names[type]);
2978 
2979 	/* allocate per filehandle data */
2980 	fh = kmalloc(sizeof(*fh), GFP_KERNEL);
2981 	if (unlikely(!fh))
2982 		return -ENOMEM;
2983 	btv->users++;
2984 	file->private_data = fh;
2985 
2986 	*fh = btv->init;
2987 	v4l2_fh_init(&fh->fh, vdev);
2988 
2989 	fh->type = type;
2990 	fh->ov.setup_ok = 0;
2991 
2992 	videobuf_queue_sg_init(&fh->cap, &bttv_video_qops,
2993 			    &btv->c.pci->dev, &btv->s_lock,
2994 			    V4L2_BUF_TYPE_VIDEO_CAPTURE,
2995 			    V4L2_FIELD_INTERLACED,
2996 			    sizeof(struct bttv_buffer),
2997 			    fh, &btv->lock);
2998 	videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops,
2999 			    &btv->c.pci->dev, &btv->s_lock,
3000 			    V4L2_BUF_TYPE_VBI_CAPTURE,
3001 			    V4L2_FIELD_SEQ_TB,
3002 			    sizeof(struct bttv_buffer),
3003 			    fh, &btv->lock);
3004 	set_tvnorm(btv,btv->tvnorm);
3005 	set_input(btv, btv->input, btv->tvnorm);
3006 	audio_mute(btv, btv->mute);
3007 
3008 	/* The V4L2 spec requires one global set of cropping parameters
3009 	   which only change on request. These are stored in btv->crop[1].
3010 	   However for compatibility with V4L apps and cropping unaware
3011 	   V4L2 apps we now reset the cropping parameters as seen through
3012 	   this fh, which is to say VIDIOC_G_SELECTION and scaling limit checks
3013 	   will use btv->crop[0], the default cropping parameters for the
3014 	   current video standard, and VIDIOC_S_FMT will not implicitly
3015 	   change the cropping parameters until VIDIOC_S_SELECTION has been
3016 	   called. */
3017 	fh->do_crop = !reset_crop; /* module parameter */
3018 
3019 	/* Likewise there should be one global set of VBI capture
3020 	   parameters, but for compatibility with V4L apps and earlier
3021 	   driver versions each fh has its own parameters. */
3022 	bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3023 
3024 	bttv_field_count(btv);
3025 	v4l2_fh_add(&fh->fh);
3026 	return 0;
3027 }
3028 
3029 static int bttv_release(struct file *file)
3030 {
3031 	struct bttv_fh *fh = file->private_data;
3032 	struct bttv *btv = fh->btv;
3033 
3034 	/* turn off overlay */
3035 	if (check_btres(fh, RESOURCE_OVERLAY))
3036 		bttv_switch_overlay(btv,fh,NULL);
3037 
3038 	/* stop video capture */
3039 	if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
3040 		videobuf_streamoff(&fh->cap);
3041 		free_btres_lock(btv,fh,RESOURCE_VIDEO_STREAM);
3042 	}
3043 	if (fh->cap.read_buf) {
3044 		buffer_release(&fh->cap,fh->cap.read_buf);
3045 		kfree(fh->cap.read_buf);
3046 	}
3047 	if (check_btres(fh, RESOURCE_VIDEO_READ)) {
3048 		free_btres_lock(btv, fh, RESOURCE_VIDEO_READ);
3049 	}
3050 
3051 	/* stop vbi capture */
3052 	if (check_btres(fh, RESOURCE_VBI)) {
3053 		videobuf_stop(&fh->vbi);
3054 		free_btres_lock(btv,fh,RESOURCE_VBI);
3055 	}
3056 
3057 	/* free stuff */
3058 
3059 	videobuf_mmap_free(&fh->cap);
3060 	videobuf_mmap_free(&fh->vbi);
3061 	file->private_data = NULL;
3062 
3063 	btv->users--;
3064 	bttv_field_count(btv);
3065 
3066 	if (!btv->users)
3067 		audio_mute(btv, btv->mute);
3068 
3069 	v4l2_fh_del(&fh->fh);
3070 	v4l2_fh_exit(&fh->fh);
3071 	kfree(fh);
3072 	return 0;
3073 }
3074 
3075 static int
3076 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3077 {
3078 	struct bttv_fh *fh = file->private_data;
3079 
3080 	dprintk("%d: mmap type=%s 0x%lx+%ld\n",
3081 		fh->btv->c.nr, v4l2_type_names[fh->type],
3082 		vma->vm_start, vma->vm_end - vma->vm_start);
3083 	return videobuf_mmap_mapper(bttv_queue(fh),vma);
3084 }
3085 
3086 static const struct v4l2_file_operations bttv_fops =
3087 {
3088 	.owner		  = THIS_MODULE,
3089 	.open		  = bttv_open,
3090 	.release	  = bttv_release,
3091 	.unlocked_ioctl	  = video_ioctl2,
3092 	.read		  = bttv_read,
3093 	.mmap		  = bttv_mmap,
3094 	.poll		  = bttv_poll,
3095 };
3096 
3097 static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
3098 	.vidioc_querycap                = bttv_querycap,
3099 	.vidioc_enum_fmt_vid_cap        = bttv_enum_fmt_vid_cap,
3100 	.vidioc_g_fmt_vid_cap           = bttv_g_fmt_vid_cap,
3101 	.vidioc_try_fmt_vid_cap         = bttv_try_fmt_vid_cap,
3102 	.vidioc_s_fmt_vid_cap           = bttv_s_fmt_vid_cap,
3103 	.vidioc_enum_fmt_vid_overlay    = bttv_enum_fmt_vid_overlay,
3104 	.vidioc_g_fmt_vid_overlay       = bttv_g_fmt_vid_overlay,
3105 	.vidioc_try_fmt_vid_overlay     = bttv_try_fmt_vid_overlay,
3106 	.vidioc_s_fmt_vid_overlay       = bttv_s_fmt_vid_overlay,
3107 	.vidioc_g_fmt_vbi_cap           = bttv_g_fmt_vbi_cap,
3108 	.vidioc_try_fmt_vbi_cap         = bttv_try_fmt_vbi_cap,
3109 	.vidioc_s_fmt_vbi_cap           = bttv_s_fmt_vbi_cap,
3110 	.vidioc_g_pixelaspect           = bttv_g_pixelaspect,
3111 	.vidioc_reqbufs                 = bttv_reqbufs,
3112 	.vidioc_querybuf                = bttv_querybuf,
3113 	.vidioc_qbuf                    = bttv_qbuf,
3114 	.vidioc_dqbuf                   = bttv_dqbuf,
3115 	.vidioc_s_std                   = bttv_s_std,
3116 	.vidioc_g_std                   = bttv_g_std,
3117 	.vidioc_enum_input              = bttv_enum_input,
3118 	.vidioc_g_input                 = bttv_g_input,
3119 	.vidioc_s_input                 = bttv_s_input,
3120 	.vidioc_streamon                = bttv_streamon,
3121 	.vidioc_streamoff               = bttv_streamoff,
3122 	.vidioc_g_tuner                 = bttv_g_tuner,
3123 	.vidioc_s_tuner                 = bttv_s_tuner,
3124 	.vidioc_g_selection             = bttv_g_selection,
3125 	.vidioc_s_selection             = bttv_s_selection,
3126 	.vidioc_g_fbuf                  = bttv_g_fbuf,
3127 	.vidioc_s_fbuf                  = bttv_s_fbuf,
3128 	.vidioc_overlay                 = bttv_overlay,
3129 	.vidioc_g_parm                  = bttv_g_parm,
3130 	.vidioc_g_frequency             = bttv_g_frequency,
3131 	.vidioc_s_frequency             = bttv_s_frequency,
3132 	.vidioc_log_status		= bttv_log_status,
3133 	.vidioc_querystd		= bttv_querystd,
3134 	.vidioc_subscribe_event		= v4l2_ctrl_subscribe_event,
3135 	.vidioc_unsubscribe_event	= v4l2_event_unsubscribe,
3136 #ifdef CONFIG_VIDEO_ADV_DEBUG
3137 	.vidioc_g_register		= bttv_g_register,
3138 	.vidioc_s_register		= bttv_s_register,
3139 #endif
3140 };
3141 
3142 static struct video_device bttv_video_template = {
3143 	.fops         = &bttv_fops,
3144 	.ioctl_ops    = &bttv_ioctl_ops,
3145 	.tvnorms      = BTTV_NORMS,
3146 };
3147 
3148 /* ----------------------------------------------------------------------- */
3149 /* radio interface                                                         */
3150 
3151 static int radio_open(struct file *file)
3152 {
3153 	struct video_device *vdev = video_devdata(file);
3154 	struct bttv *btv = video_drvdata(file);
3155 	struct bttv_fh *fh;
3156 
3157 	dprintk("open dev=%s\n", video_device_node_name(vdev));
3158 
3159 	dprintk("%d: open called (radio)\n", btv->c.nr);
3160 
3161 	/* allocate per filehandle data */
3162 	fh = kmalloc(sizeof(*fh), GFP_KERNEL);
3163 	if (unlikely(!fh))
3164 		return -ENOMEM;
3165 	file->private_data = fh;
3166 	*fh = btv->init;
3167 	v4l2_fh_init(&fh->fh, vdev);
3168 
3169 	btv->radio_user++;
3170 	audio_mute(btv, btv->mute);
3171 
3172 	v4l2_fh_add(&fh->fh);
3173 
3174 	return 0;
3175 }
3176 
3177 static int radio_release(struct file *file)
3178 {
3179 	struct bttv_fh *fh = file->private_data;
3180 	struct bttv *btv = fh->btv;
3181 	struct saa6588_command cmd;
3182 
3183 	file->private_data = NULL;
3184 	v4l2_fh_del(&fh->fh);
3185 	v4l2_fh_exit(&fh->fh);
3186 	kfree(fh);
3187 
3188 	btv->radio_user--;
3189 
3190 	bttv_call_all(btv, core, ioctl, SAA6588_CMD_CLOSE, &cmd);
3191 
3192 	if (btv->radio_user == 0)
3193 		btv->has_radio_tuner = 0;
3194 	return 0;
3195 }
3196 
3197 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3198 {
3199 	struct bttv_fh *fh = priv;
3200 	struct bttv *btv = fh->btv;
3201 
3202 	if (0 != t->index)
3203 		return -EINVAL;
3204 	strscpy(t->name, "Radio", sizeof(t->name));
3205 	t->type = V4L2_TUNER_RADIO;
3206 	radio_enable(btv);
3207 
3208 	bttv_call_all(btv, tuner, g_tuner, t);
3209 
3210 	if (btv->audio_mode_gpio)
3211 		btv->audio_mode_gpio(btv, t, 0);
3212 
3213 	if (btv->has_tea575x)
3214 		return snd_tea575x_g_tuner(&btv->tea, t);
3215 
3216 	return 0;
3217 }
3218 
3219 static int radio_s_tuner(struct file *file, void *priv,
3220 					const struct v4l2_tuner *t)
3221 {
3222 	struct bttv_fh *fh = priv;
3223 	struct bttv *btv = fh->btv;
3224 
3225 	if (0 != t->index)
3226 		return -EINVAL;
3227 
3228 	radio_enable(btv);
3229 	bttv_call_all(btv, tuner, s_tuner, t);
3230 	return 0;
3231 }
3232 
3233 static int radio_s_hw_freq_seek(struct file *file, void *priv,
3234 					const struct v4l2_hw_freq_seek *a)
3235 {
3236 	struct bttv_fh *fh = priv;
3237 	struct bttv *btv = fh->btv;
3238 
3239 	if (btv->has_tea575x)
3240 		return snd_tea575x_s_hw_freq_seek(file, &btv->tea, a);
3241 
3242 	return -ENOTTY;
3243 }
3244 
3245 static int radio_enum_freq_bands(struct file *file, void *priv,
3246 					 struct v4l2_frequency_band *band)
3247 {
3248 	struct bttv_fh *fh = priv;
3249 	struct bttv *btv = fh->btv;
3250 
3251 	if (btv->has_tea575x)
3252 		return snd_tea575x_enum_freq_bands(&btv->tea, band);
3253 
3254 	return -ENOTTY;
3255 }
3256 
3257 static ssize_t radio_read(struct file *file, char __user *data,
3258 			 size_t count, loff_t *ppos)
3259 {
3260 	struct bttv_fh *fh = file->private_data;
3261 	struct bttv *btv = fh->btv;
3262 	struct saa6588_command cmd;
3263 
3264 	cmd.block_count = count / 3;
3265 	cmd.nonblocking = file->f_flags & O_NONBLOCK;
3266 	cmd.buffer = data;
3267 	cmd.instance = file;
3268 	cmd.result = -ENODEV;
3269 	radio_enable(btv);
3270 
3271 	bttv_call_all(btv, core, ioctl, SAA6588_CMD_READ, &cmd);
3272 
3273 	return cmd.result;
3274 }
3275 
3276 static __poll_t radio_poll(struct file *file, poll_table *wait)
3277 {
3278 	struct bttv_fh *fh = file->private_data;
3279 	struct bttv *btv = fh->btv;
3280 	__poll_t req_events = poll_requested_events(wait);
3281 	struct saa6588_command cmd;
3282 	__poll_t res = 0;
3283 
3284 	if (v4l2_event_pending(&fh->fh))
3285 		res = EPOLLPRI;
3286 	else if (req_events & EPOLLPRI)
3287 		poll_wait(file, &fh->fh.wait, wait);
3288 	radio_enable(btv);
3289 	cmd.instance = file;
3290 	cmd.event_list = wait;
3291 	cmd.poll_mask = res;
3292 	bttv_call_all(btv, core, ioctl, SAA6588_CMD_POLL, &cmd);
3293 
3294 	return cmd.poll_mask;
3295 }
3296 
3297 static const struct v4l2_file_operations radio_fops =
3298 {
3299 	.owner	  = THIS_MODULE,
3300 	.open	  = radio_open,
3301 	.read     = radio_read,
3302 	.release  = radio_release,
3303 	.unlocked_ioctl = video_ioctl2,
3304 	.poll     = radio_poll,
3305 };
3306 
3307 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
3308 	.vidioc_querycap        = bttv_querycap,
3309 	.vidioc_log_status	= bttv_log_status,
3310 	.vidioc_g_tuner         = radio_g_tuner,
3311 	.vidioc_s_tuner         = radio_s_tuner,
3312 	.vidioc_g_frequency     = bttv_g_frequency,
3313 	.vidioc_s_frequency     = bttv_s_frequency,
3314 	.vidioc_s_hw_freq_seek	= radio_s_hw_freq_seek,
3315 	.vidioc_enum_freq_bands	= radio_enum_freq_bands,
3316 	.vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
3317 	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
3318 };
3319 
3320 static struct video_device radio_template = {
3321 	.fops      = &radio_fops,
3322 	.ioctl_ops = &radio_ioctl_ops,
3323 };
3324 
3325 /* ----------------------------------------------------------------------- */
3326 /* some debug code                                                         */
3327 
3328 static int bttv_risc_decode(u32 risc)
3329 {
3330 	static char *instr[16] = {
3331 		[ BT848_RISC_WRITE     >> 28 ] = "write",
3332 		[ BT848_RISC_SKIP      >> 28 ] = "skip",
3333 		[ BT848_RISC_WRITEC    >> 28 ] = "writec",
3334 		[ BT848_RISC_JUMP      >> 28 ] = "jump",
3335 		[ BT848_RISC_SYNC      >> 28 ] = "sync",
3336 		[ BT848_RISC_WRITE123  >> 28 ] = "write123",
3337 		[ BT848_RISC_SKIP123   >> 28 ] = "skip123",
3338 		[ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3339 	};
3340 	static int incr[16] = {
3341 		[ BT848_RISC_WRITE     >> 28 ] = 2,
3342 		[ BT848_RISC_JUMP      >> 28 ] = 2,
3343 		[ BT848_RISC_SYNC      >> 28 ] = 2,
3344 		[ BT848_RISC_WRITE123  >> 28 ] = 5,
3345 		[ BT848_RISC_SKIP123   >> 28 ] = 2,
3346 		[ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3347 	};
3348 	static char *bits[] = {
3349 		"be0",  "be1",  "be2",  "be3/resync",
3350 		"set0", "set1", "set2", "set3",
3351 		"clr0", "clr1", "clr2", "clr3",
3352 		"irq",  "res",  "eol",  "sol",
3353 	};
3354 	int i;
3355 
3356 	pr_cont("0x%08x [ %s", risc,
3357 	       instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3358 	for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3359 		if (risc & (1 << (i + 12)))
3360 			pr_cont(" %s", bits[i]);
3361 	pr_cont(" count=%d ]\n", risc & 0xfff);
3362 	return incr[risc >> 28] ? incr[risc >> 28] : 1;
3363 }
3364 
3365 static void bttv_risc_disasm(struct bttv *btv,
3366 			     struct btcx_riscmem *risc)
3367 {
3368 	unsigned int i,j,n;
3369 
3370 	pr_info("%s: risc disasm: %p [dma=0x%08lx]\n",
3371 		btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma);
3372 	for (i = 0; i < (risc->size >> 2); i += n) {
3373 		pr_info("%s:   0x%lx: ",
3374 			btv->c.v4l2_dev.name,
3375 			(unsigned long)(risc->dma + (i<<2)));
3376 		n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
3377 		for (j = 1; j < n; j++)
3378 			pr_info("%s:   0x%lx: 0x%08x [ arg #%d ]\n",
3379 				btv->c.v4l2_dev.name,
3380 				(unsigned long)(risc->dma + ((i+j)<<2)),
3381 				risc->cpu[i+j], j);
3382 		if (0 == risc->cpu[i])
3383 			break;
3384 	}
3385 }
3386 
3387 static void bttv_print_riscaddr(struct bttv *btv)
3388 {
3389 	pr_info("  main: %08llx\n", (unsigned long long)btv->main.dma);
3390 	pr_info("  vbi : o=%08llx e=%08llx\n",
3391 		btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3392 		btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3393 	pr_info("  cap : o=%08llx e=%08llx\n",
3394 		btv->curr.top
3395 		? (unsigned long long)btv->curr.top->top.dma : 0,
3396 		btv->curr.bottom
3397 		? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3398 	pr_info("  scr : o=%08llx e=%08llx\n",
3399 		btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3400 		btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3401 	bttv_risc_disasm(btv, &btv->main);
3402 }
3403 
3404 /* ----------------------------------------------------------------------- */
3405 /* irq handler                                                             */
3406 
3407 static char *irq_name[] = {
3408 	"FMTCHG",  // format change detected (525 vs. 625)
3409 	"VSYNC",   // vertical sync (new field)
3410 	"HSYNC",   // horizontal sync
3411 	"OFLOW",   // chroma/luma AGC overflow
3412 	"HLOCK",   // horizontal lock changed
3413 	"VPRES",   // video presence changed
3414 	"6", "7",
3415 	"I2CDONE", // hw irc operation finished
3416 	"GPINT",   // gpio port triggered irq
3417 	"10",
3418 	"RISCI",   // risc instruction triggered irq
3419 	"FBUS",    // pixel data fifo dropped data (high pci bus latencies)
3420 	"FTRGT",   // pixel data fifo overrun
3421 	"FDSR",    // fifo data stream resyncronisation
3422 	"PPERR",   // parity error (data transfer)
3423 	"RIPERR",  // parity error (read risc instructions)
3424 	"PABORT",  // pci abort
3425 	"OCERR",   // risc instruction error
3426 	"SCERR",   // syncronisation error
3427 };
3428 
3429 static void bttv_print_irqbits(u32 print, u32 mark)
3430 {
3431 	unsigned int i;
3432 
3433 	pr_cont("bits:");
3434 	for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3435 		if (print & (1 << i))
3436 			pr_cont(" %s", irq_name[i]);
3437 		if (mark & (1 << i))
3438 			pr_cont("*");
3439 	}
3440 }
3441 
3442 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3443 {
3444 	pr_warn("%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3445 		btv->c.nr,
3446 		(unsigned long)btv->main.dma,
3447 		(unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
3448 		(unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
3449 		(unsigned long)rc);
3450 
3451 	if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3452 		pr_notice("%d: Oh, there (temporarily?) is no input signal. Ok, then this is harmless, don't worry ;)\n",
3453 			  btv->c.nr);
3454 		return;
3455 	}
3456 	pr_notice("%d: Uhm. Looks like we have unusual high IRQ latencies\n",
3457 		  btv->c.nr);
3458 	pr_notice("%d: Lets try to catch the culprit red-handed ...\n",
3459 		  btv->c.nr);
3460 	dump_stack();
3461 }
3462 
3463 static int
3464 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3465 {
3466 	struct bttv_buffer *item;
3467 
3468 	memset(set,0,sizeof(*set));
3469 
3470 	/* capture request ? */
3471 	if (!list_empty(&btv->capture)) {
3472 		set->frame_irq = 1;
3473 		item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3474 		if (V4L2_FIELD_HAS_TOP(item->vb.field))
3475 			set->top    = item;
3476 		if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3477 			set->bottom = item;
3478 
3479 		/* capture request for other field ? */
3480 		if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3481 		    (item->vb.queue.next != &btv->capture)) {
3482 			item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3483 			/* Mike Isely <isely@pobox.com> - Only check
3484 			 * and set up the bottom field in the logic
3485 			 * below.  Don't ever do the top field.  This
3486 			 * of course means that if we set up the
3487 			 * bottom field in the above code that we'll
3488 			 * actually skip a field.  But that's OK.
3489 			 * Having processed only a single buffer this
3490 			 * time, then the next time around the first
3491 			 * available buffer should be for a top field.
3492 			 * That will then cause us here to set up a
3493 			 * top then a bottom field in the normal way.
3494 			 * The alternative to this understanding is
3495 			 * that we set up the second available buffer
3496 			 * as a top field, but that's out of order
3497 			 * since this driver always processes the top
3498 			 * field first - the effect will be the two
3499 			 * buffers being returned in the wrong order,
3500 			 * with the second buffer also being delayed
3501 			 * by one field time (owing to the fifo nature
3502 			 * of videobuf).  Worse still, we'll be stuck
3503 			 * doing fields out of order now every time
3504 			 * until something else causes a field to be
3505 			 * dropped.  By effectively forcing a field to
3506 			 * drop this way then we always get back into
3507 			 * sync within a single frame time.  (Out of
3508 			 * order fields can screw up deinterlacing
3509 			 * algorithms.) */
3510 			if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3511 				if (NULL == set->bottom &&
3512 				    V4L2_FIELD_BOTTOM == item->vb.field) {
3513 					set->bottom = item;
3514 				}
3515 				if (NULL != set->top  &&  NULL != set->bottom)
3516 					set->top_irq = 2;
3517 			}
3518 		}
3519 	}
3520 
3521 	/* screen overlay ? */
3522 	if (NULL != btv->screen) {
3523 		if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3524 			if (NULL == set->top && NULL == set->bottom) {
3525 				set->top    = btv->screen;
3526 				set->bottom = btv->screen;
3527 			}
3528 		} else {
3529 			if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3530 			    NULL == set->top) {
3531 				set->top = btv->screen;
3532 			}
3533 			if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3534 			    NULL == set->bottom) {
3535 				set->bottom = btv->screen;
3536 			}
3537 		}
3538 	}
3539 
3540 	dprintk("%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3541 		btv->c.nr, set->top, set->bottom,
3542 		btv->screen, set->frame_irq, set->top_irq);
3543 	return 0;
3544 }
3545 
3546 static void
3547 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3548 		      struct bttv_buffer_set *curr, unsigned int state)
3549 {
3550 	u64 ts = ktime_get_ns();
3551 
3552 	if (wakeup->top == wakeup->bottom) {
3553 		if (NULL != wakeup->top && curr->top != wakeup->top) {
3554 			if (irq_debug > 1)
3555 				pr_debug("%d: wakeup: both=%p\n",
3556 					 btv->c.nr, wakeup->top);
3557 			wakeup->top->vb.ts = ts;
3558 			wakeup->top->vb.field_count = btv->field_count;
3559 			wakeup->top->vb.state = state;
3560 			wake_up(&wakeup->top->vb.done);
3561 		}
3562 	} else {
3563 		if (NULL != wakeup->top && curr->top != wakeup->top) {
3564 			if (irq_debug > 1)
3565 				pr_debug("%d: wakeup: top=%p\n",
3566 					 btv->c.nr, wakeup->top);
3567 			wakeup->top->vb.ts = ts;
3568 			wakeup->top->vb.field_count = btv->field_count;
3569 			wakeup->top->vb.state = state;
3570 			wake_up(&wakeup->top->vb.done);
3571 		}
3572 		if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3573 			if (irq_debug > 1)
3574 				pr_debug("%d: wakeup: bottom=%p\n",
3575 					 btv->c.nr, wakeup->bottom);
3576 			wakeup->bottom->vb.ts = ts;
3577 			wakeup->bottom->vb.field_count = btv->field_count;
3578 			wakeup->bottom->vb.state = state;
3579 			wake_up(&wakeup->bottom->vb.done);
3580 		}
3581 	}
3582 }
3583 
3584 static void
3585 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3586 		    unsigned int state)
3587 {
3588 	if (NULL == wakeup)
3589 		return;
3590 
3591 	wakeup->vb.ts = ktime_get_ns();
3592 	wakeup->vb.field_count = btv->field_count;
3593 	wakeup->vb.state = state;
3594 	wake_up(&wakeup->vb.done);
3595 }
3596 
3597 static void bttv_irq_timeout(struct timer_list *t)
3598 {
3599 	struct bttv *btv = from_timer(btv, t, timeout);
3600 	struct bttv_buffer_set old,new;
3601 	struct bttv_buffer *ovbi;
3602 	struct bttv_buffer *item;
3603 	unsigned long flags;
3604 
3605 	if (bttv_verbose) {
3606 		pr_info("%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3607 			btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3608 			btread(BT848_RISC_COUNT));
3609 		bttv_print_irqbits(btread(BT848_INT_STAT),0);
3610 		pr_cont("\n");
3611 	}
3612 
3613 	spin_lock_irqsave(&btv->s_lock,flags);
3614 
3615 	/* deactivate stuff */
3616 	memset(&new,0,sizeof(new));
3617 	old  = btv->curr;
3618 	ovbi = btv->cvbi;
3619 	btv->curr = new;
3620 	btv->cvbi = NULL;
3621 	btv->loop_irq = 0;
3622 	bttv_buffer_activate_video(btv, &new);
3623 	bttv_buffer_activate_vbi(btv,   NULL);
3624 	bttv_set_dma(btv, 0);
3625 
3626 	/* wake up */
3627 	bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
3628 	bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
3629 
3630 	/* cancel all outstanding capture / vbi requests */
3631 	while (!list_empty(&btv->capture)) {
3632 		item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3633 		list_del(&item->vb.queue);
3634 		item->vb.state = VIDEOBUF_ERROR;
3635 		wake_up(&item->vb.done);
3636 	}
3637 	while (!list_empty(&btv->vcapture)) {
3638 		item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3639 		list_del(&item->vb.queue);
3640 		item->vb.state = VIDEOBUF_ERROR;
3641 		wake_up(&item->vb.done);
3642 	}
3643 
3644 	btv->errors++;
3645 	spin_unlock_irqrestore(&btv->s_lock,flags);
3646 }
3647 
3648 static void
3649 bttv_irq_wakeup_top(struct bttv *btv)
3650 {
3651 	struct bttv_buffer *wakeup = btv->curr.top;
3652 
3653 	if (NULL == wakeup)
3654 		return;
3655 
3656 	spin_lock(&btv->s_lock);
3657 	btv->curr.top_irq = 0;
3658 	btv->curr.top = NULL;
3659 	bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3660 
3661 	wakeup->vb.ts = ktime_get_ns();
3662 	wakeup->vb.field_count = btv->field_count;
3663 	wakeup->vb.state = VIDEOBUF_DONE;
3664 	wake_up(&wakeup->vb.done);
3665 	spin_unlock(&btv->s_lock);
3666 }
3667 
3668 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
3669 {
3670 	if (rc < risc->dma)
3671 		return 0;
3672 	if (rc > risc->dma + risc->size)
3673 		return 0;
3674 	return 1;
3675 }
3676 
3677 static void
3678 bttv_irq_switch_video(struct bttv *btv)
3679 {
3680 	struct bttv_buffer_set new;
3681 	struct bttv_buffer_set old;
3682 	dma_addr_t rc;
3683 
3684 	spin_lock(&btv->s_lock);
3685 
3686 	/* new buffer set */
3687 	bttv_irq_next_video(btv, &new);
3688 	rc = btread(BT848_RISC_COUNT);
3689 	if ((btv->curr.top    && is_active(&btv->curr.top->top,       rc)) ||
3690 	    (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
3691 		btv->framedrop++;
3692 		if (debug_latency)
3693 			bttv_irq_debug_low_latency(btv, rc);
3694 		spin_unlock(&btv->s_lock);
3695 		return;
3696 	}
3697 
3698 	/* switch over */
3699 	old = btv->curr;
3700 	btv->curr = new;
3701 	btv->loop_irq &= ~1;
3702 	bttv_buffer_activate_video(btv, &new);
3703 	bttv_set_dma(btv, 0);
3704 
3705 	/* switch input */
3706 	if (UNSET != btv->new_input) {
3707 		video_mux(btv,btv->new_input);
3708 		btv->new_input = UNSET;
3709 	}
3710 
3711 	/* wake up finished buffers */
3712 	bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
3713 	spin_unlock(&btv->s_lock);
3714 }
3715 
3716 static void
3717 bttv_irq_switch_vbi(struct bttv *btv)
3718 {
3719 	struct bttv_buffer *new = NULL;
3720 	struct bttv_buffer *old;
3721 	u32 rc;
3722 
3723 	spin_lock(&btv->s_lock);
3724 
3725 	if (!list_empty(&btv->vcapture))
3726 		new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3727 	old = btv->cvbi;
3728 
3729 	rc = btread(BT848_RISC_COUNT);
3730 	if (NULL != old && (is_active(&old->top,    rc) ||
3731 			    is_active(&old->bottom, rc))) {
3732 		btv->framedrop++;
3733 		if (debug_latency)
3734 			bttv_irq_debug_low_latency(btv, rc);
3735 		spin_unlock(&btv->s_lock);
3736 		return;
3737 	}
3738 
3739 	/* switch */
3740 	btv->cvbi = new;
3741 	btv->loop_irq &= ~4;
3742 	bttv_buffer_activate_vbi(btv, new);
3743 	bttv_set_dma(btv, 0);
3744 
3745 	bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
3746 	spin_unlock(&btv->s_lock);
3747 }
3748 
3749 static irqreturn_t bttv_irq(int irq, void *dev_id)
3750 {
3751 	u32 stat,astat;
3752 	u32 dstat;
3753 	int count;
3754 	struct bttv *btv;
3755 	int handled = 0;
3756 
3757 	btv=(struct bttv *)dev_id;
3758 
3759 	count=0;
3760 	while (1) {
3761 		/* get/clear interrupt status bits */
3762 		stat=btread(BT848_INT_STAT);
3763 		astat=stat&btread(BT848_INT_MASK);
3764 		if (!astat)
3765 			break;
3766 		handled = 1;
3767 		btwrite(stat,BT848_INT_STAT);
3768 
3769 		/* get device status bits */
3770 		dstat=btread(BT848_DSTATUS);
3771 
3772 		if (irq_debug) {
3773 			pr_debug("%d: irq loop=%d fc=%d riscs=%x, riscc=%08x, ",
3774 				 btv->c.nr, count, btv->field_count,
3775 				 stat>>28, btread(BT848_RISC_COUNT));
3776 			bttv_print_irqbits(stat,astat);
3777 			if (stat & BT848_INT_HLOCK)
3778 				pr_cont("   HLOC => %s",
3779 					dstat & BT848_DSTATUS_HLOC
3780 					? "yes" : "no");
3781 			if (stat & BT848_INT_VPRES)
3782 				pr_cont("   PRES => %s",
3783 					dstat & BT848_DSTATUS_PRES
3784 					? "yes" : "no");
3785 			if (stat & BT848_INT_FMTCHG)
3786 				pr_cont("   NUML => %s",
3787 					dstat & BT848_DSTATUS_NUML
3788 					? "625" : "525");
3789 			pr_cont("\n");
3790 		}
3791 
3792 		if (astat&BT848_INT_VSYNC)
3793 			btv->field_count++;
3794 
3795 		if ((astat & BT848_INT_GPINT) && btv->remote) {
3796 			bttv_input_irq(btv);
3797 		}
3798 
3799 		if (astat & BT848_INT_I2CDONE) {
3800 			btv->i2c_done = stat;
3801 			wake_up(&btv->i2c_queue);
3802 		}
3803 
3804 		if ((astat & BT848_INT_RISCI)  &&  (stat & (4<<28)))
3805 			bttv_irq_switch_vbi(btv);
3806 
3807 		if ((astat & BT848_INT_RISCI)  &&  (stat & (2<<28)))
3808 			bttv_irq_wakeup_top(btv);
3809 
3810 		if ((astat & BT848_INT_RISCI)  &&  (stat & (1<<28)))
3811 			bttv_irq_switch_video(btv);
3812 
3813 		if ((astat & BT848_INT_HLOCK)  &&  btv->opt_automute)
3814 			/* trigger automute */
3815 			audio_mux_gpio(btv, btv->audio_input, btv->mute);
3816 
3817 		if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
3818 			pr_info("%d: %s%s @ %08x,",
3819 				btv->c.nr,
3820 				(astat & BT848_INT_SCERR) ? "SCERR" : "",
3821 				(astat & BT848_INT_OCERR) ? "OCERR" : "",
3822 				btread(BT848_RISC_COUNT));
3823 			bttv_print_irqbits(stat,astat);
3824 			pr_cont("\n");
3825 			if (bttv_debug)
3826 				bttv_print_riscaddr(btv);
3827 		}
3828 		if (fdsr && astat & BT848_INT_FDSR) {
3829 			pr_info("%d: FDSR @ %08x\n",
3830 				btv->c.nr, btread(BT848_RISC_COUNT));
3831 			if (bttv_debug)
3832 				bttv_print_riscaddr(btv);
3833 		}
3834 
3835 		count++;
3836 		if (count > 4) {
3837 
3838 			if (count > 8 || !(astat & BT848_INT_GPINT)) {
3839 				btwrite(0, BT848_INT_MASK);
3840 
3841 				pr_err("%d: IRQ lockup, cleared int mask [",
3842 				       btv->c.nr);
3843 			} else {
3844 				pr_err("%d: IRQ lockup, clearing GPINT from int mask [",
3845 				       btv->c.nr);
3846 
3847 				btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
3848 						BT848_INT_MASK);
3849 			}
3850 
3851 			bttv_print_irqbits(stat,astat);
3852 
3853 			pr_cont("]\n");
3854 		}
3855 	}
3856 	btv->irq_total++;
3857 	if (handled)
3858 		btv->irq_me++;
3859 	return IRQ_RETVAL(handled);
3860 }
3861 
3862 
3863 /* ----------------------------------------------------------------------- */
3864 /* initialization                                                          */
3865 
3866 static void vdev_init(struct bttv *btv,
3867 		      struct video_device *vfd,
3868 		      const struct video_device *template,
3869 		      const char *type_name)
3870 {
3871 	*vfd = *template;
3872 	vfd->v4l2_dev = &btv->c.v4l2_dev;
3873 	vfd->release = video_device_release_empty;
3874 	video_set_drvdata(vfd, btv);
3875 	snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
3876 		 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
3877 		 type_name, bttv_tvcards[btv->c.type].name);
3878 	if (btv->tuner_type == TUNER_ABSENT) {
3879 		v4l2_disable_ioctl(vfd, VIDIOC_G_FREQUENCY);
3880 		v4l2_disable_ioctl(vfd, VIDIOC_S_FREQUENCY);
3881 		v4l2_disable_ioctl(vfd, VIDIOC_G_TUNER);
3882 		v4l2_disable_ioctl(vfd, VIDIOC_S_TUNER);
3883 	}
3884 }
3885 
3886 static void bttv_unregister_video(struct bttv *btv)
3887 {
3888 	video_unregister_device(&btv->video_dev);
3889 	video_unregister_device(&btv->vbi_dev);
3890 	video_unregister_device(&btv->radio_dev);
3891 }
3892 
3893 /* register video4linux devices */
3894 static int bttv_register_video(struct bttv *btv)
3895 {
3896 	if (no_overlay > 0)
3897 		pr_notice("Overlay support disabled\n");
3898 
3899 	/* video */
3900 	vdev_init(btv, &btv->video_dev, &bttv_video_template, "video");
3901 	btv->video_dev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
3902 				     V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
3903 	if (btv->tuner_type != TUNER_ABSENT)
3904 		btv->video_dev.device_caps |= V4L2_CAP_TUNER;
3905 	if (no_overlay <= 0)
3906 		btv->video_dev.device_caps |= V4L2_CAP_VIDEO_OVERLAY;
3907 
3908 	if (video_register_device(&btv->video_dev, VFL_TYPE_VIDEO,
3909 				  video_nr[btv->c.nr]) < 0)
3910 		goto err;
3911 	pr_info("%d: registered device %s\n",
3912 		btv->c.nr, video_device_node_name(&btv->video_dev));
3913 	if (device_create_file(&btv->video_dev.dev,
3914 				     &dev_attr_card)<0) {
3915 		pr_err("%d: device_create_file 'card' failed\n", btv->c.nr);
3916 		goto err;
3917 	}
3918 
3919 	/* vbi */
3920 	vdev_init(btv, &btv->vbi_dev, &bttv_video_template, "vbi");
3921 	btv->vbi_dev.device_caps = V4L2_CAP_VBI_CAPTURE | V4L2_CAP_READWRITE |
3922 				   V4L2_CAP_STREAMING | V4L2_CAP_TUNER;
3923 	if (btv->tuner_type != TUNER_ABSENT)
3924 		btv->vbi_dev.device_caps |= V4L2_CAP_TUNER;
3925 
3926 	if (video_register_device(&btv->vbi_dev, VFL_TYPE_VBI,
3927 				  vbi_nr[btv->c.nr]) < 0)
3928 		goto err;
3929 	pr_info("%d: registered device %s\n",
3930 		btv->c.nr, video_device_node_name(&btv->vbi_dev));
3931 
3932 	if (!btv->has_radio)
3933 		return 0;
3934 	/* radio */
3935 	vdev_init(btv, &btv->radio_dev, &radio_template, "radio");
3936 	btv->radio_dev.device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER;
3937 	if (btv->has_saa6588)
3938 		btv->radio_dev.device_caps |= V4L2_CAP_READWRITE |
3939 					      V4L2_CAP_RDS_CAPTURE;
3940 	if (btv->has_tea575x)
3941 		btv->radio_dev.device_caps |= V4L2_CAP_HW_FREQ_SEEK;
3942 	btv->radio_dev.ctrl_handler = &btv->radio_ctrl_handler;
3943 	if (video_register_device(&btv->radio_dev, VFL_TYPE_RADIO,
3944 				  radio_nr[btv->c.nr]) < 0)
3945 		goto err;
3946 	pr_info("%d: registered device %s\n",
3947 		btv->c.nr, video_device_node_name(&btv->radio_dev));
3948 
3949 	/* all done */
3950 	return 0;
3951 
3952  err:
3953 	bttv_unregister_video(btv);
3954 	return -1;
3955 }
3956 
3957 
3958 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
3959 /* response on cards with no firmware is not enabled by OF */
3960 static void pci_set_command(struct pci_dev *dev)
3961 {
3962 #if defined(__powerpc__)
3963 	unsigned int cmd;
3964 
3965 	pci_read_config_dword(dev, PCI_COMMAND, &cmd);
3966 	cmd = (cmd | PCI_COMMAND_MEMORY );
3967 	pci_write_config_dword(dev, PCI_COMMAND, cmd);
3968 #endif
3969 }
3970 
3971 static int bttv_probe(struct pci_dev *dev, const struct pci_device_id *pci_id)
3972 {
3973 	struct v4l2_frequency init_freq = {
3974 		.tuner = 0,
3975 		.type = V4L2_TUNER_ANALOG_TV,
3976 		.frequency = 980,
3977 	};
3978 	int result;
3979 	unsigned char lat;
3980 	struct bttv *btv;
3981 	struct v4l2_ctrl_handler *hdl;
3982 
3983 	if (bttv_num == BTTV_MAX)
3984 		return -ENOMEM;
3985 	pr_info("Bt8xx card found (%d)\n", bttv_num);
3986 	bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL);
3987 	if (btv == NULL) {
3988 		pr_err("out of memory\n");
3989 		return -ENOMEM;
3990 	}
3991 	btv->c.nr  = bttv_num;
3992 	snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name),
3993 			"bttv%d", btv->c.nr);
3994 
3995 	/* initialize structs / fill in defaults */
3996 	mutex_init(&btv->lock);
3997 	spin_lock_init(&btv->s_lock);
3998 	spin_lock_init(&btv->gpio_lock);
3999 	init_waitqueue_head(&btv->i2c_queue);
4000 	INIT_LIST_HEAD(&btv->c.subs);
4001 	INIT_LIST_HEAD(&btv->capture);
4002 	INIT_LIST_HEAD(&btv->vcapture);
4003 
4004 	timer_setup(&btv->timeout, bttv_irq_timeout, 0);
4005 
4006 	btv->i2c_rc = -1;
4007 	btv->tuner_type  = UNSET;
4008 	btv->new_input   = UNSET;
4009 	btv->has_radio=radio[btv->c.nr];
4010 
4011 	/* pci stuff (init, get irq/mmio, ... */
4012 	btv->c.pci = dev;
4013 	btv->id  = dev->device;
4014 	if (pci_enable_device(dev)) {
4015 		pr_warn("%d: Can't enable device\n", btv->c.nr);
4016 		return -EIO;
4017 	}
4018 	if (pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
4019 		pr_warn("%d: No suitable DMA available\n", btv->c.nr);
4020 		return -EIO;
4021 	}
4022 	if (!request_mem_region(pci_resource_start(dev,0),
4023 				pci_resource_len(dev,0),
4024 				btv->c.v4l2_dev.name)) {
4025 		pr_warn("%d: can't request iomem (0x%llx)\n",
4026 			btv->c.nr,
4027 			(unsigned long long)pci_resource_start(dev, 0));
4028 		return -EBUSY;
4029 	}
4030 	pci_set_master(dev);
4031 	pci_set_command(dev);
4032 
4033 	result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev);
4034 	if (result < 0) {
4035 		pr_warn("%d: v4l2_device_register() failed\n", btv->c.nr);
4036 		goto fail0;
4037 	}
4038 	hdl = &btv->ctrl_handler;
4039 	v4l2_ctrl_handler_init(hdl, 20);
4040 	btv->c.v4l2_dev.ctrl_handler = hdl;
4041 	v4l2_ctrl_handler_init(&btv->radio_ctrl_handler, 6);
4042 
4043 	btv->revision = dev->revision;
4044 	pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4045 	pr_info("%d: Bt%d (rev %d) at %s, irq: %d, latency: %d, mmio: 0x%llx\n",
4046 		bttv_num, btv->id, btv->revision, pci_name(dev),
4047 		btv->c.pci->irq, lat,
4048 		(unsigned long long)pci_resource_start(dev, 0));
4049 	schedule();
4050 
4051 	btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4052 	if (NULL == btv->bt848_mmio) {
4053 		pr_err("%d: ioremap() failed\n", btv->c.nr);
4054 		result = -EIO;
4055 		goto fail1;
4056 	}
4057 
4058 	/* identify card */
4059 	bttv_idcard(btv);
4060 
4061 	/* disable irqs, register irq handler */
4062 	btwrite(0, BT848_INT_MASK);
4063 	result = request_irq(btv->c.pci->irq, bttv_irq,
4064 	    IRQF_SHARED, btv->c.v4l2_dev.name, (void *)btv);
4065 	if (result < 0) {
4066 		pr_err("%d: can't get IRQ %d\n",
4067 		       bttv_num, btv->c.pci->irq);
4068 		goto fail1;
4069 	}
4070 
4071 	if (0 != bttv_handle_chipset(btv)) {
4072 		result = -EIO;
4073 		goto fail2;
4074 	}
4075 
4076 	/* init options from insmod args */
4077 	btv->opt_combfilter = combfilter;
4078 	bttv_ctrl_combfilter.def = combfilter;
4079 	bttv_ctrl_lumafilter.def = lumafilter;
4080 	btv->opt_automute   = automute;
4081 	bttv_ctrl_automute.def = automute;
4082 	bttv_ctrl_agc_crush.def = agc_crush;
4083 	btv->opt_vcr_hack   = vcr_hack;
4084 	bttv_ctrl_vcr_hack.def = vcr_hack;
4085 	bttv_ctrl_whitecrush_upper.def = whitecrush_upper;
4086 	bttv_ctrl_whitecrush_lower.def = whitecrush_lower;
4087 	btv->opt_uv_ratio   = uv_ratio;
4088 	bttv_ctrl_uv_ratio.def = uv_ratio;
4089 	bttv_ctrl_full_luma.def = full_luma_range;
4090 	bttv_ctrl_coring.def = coring;
4091 
4092 	/* fill struct bttv with some useful defaults */
4093 	btv->init.btv         = btv;
4094 	btv->init.ov.w.width  = 320;
4095 	btv->init.ov.w.height = 240;
4096 	btv->init.fmt         = format_by_fourcc(V4L2_PIX_FMT_BGR24);
4097 	btv->init.width       = 320;
4098 	btv->init.height      = 240;
4099 	btv->init.ov.w.width  = 320;
4100 	btv->init.ov.w.height = 240;
4101 	btv->init.ov.field    = V4L2_FIELD_INTERLACED;
4102 	btv->input = 0;
4103 
4104 	v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4105 			V4L2_CID_BRIGHTNESS, 0, 0xff00, 0x100, 32768);
4106 	v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4107 			V4L2_CID_CONTRAST, 0, 0xff80, 0x80, 0x6c00);
4108 	v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4109 			V4L2_CID_SATURATION, 0, 0xff80, 0x80, 32768);
4110 	v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4111 			V4L2_CID_COLOR_KILLER, 0, 1, 1, 0);
4112 	v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4113 			V4L2_CID_HUE, 0, 0xff00, 0x100, 32768);
4114 	v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4115 			V4L2_CID_CHROMA_AGC, 0, 1, 1, !!chroma_agc);
4116 	v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4117 		V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
4118 	if (btv->volume_gpio)
4119 		v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4120 			V4L2_CID_AUDIO_VOLUME, 0, 0xff00, 0x100, 0xff00);
4121 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_combfilter, NULL);
4122 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_automute, NULL);
4123 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_lumafilter, NULL);
4124 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_agc_crush, NULL);
4125 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_vcr_hack, NULL);
4126 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_lower, NULL);
4127 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_upper, NULL);
4128 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_uv_ratio, NULL);
4129 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_full_luma, NULL);
4130 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_coring, NULL);
4131 
4132 	/* initialize hardware */
4133 	if (bttv_gpio)
4134 		bttv_gpio_tracking(btv,"pre-init");
4135 
4136 	bttv_risc_init_main(btv);
4137 	init_bt848(btv);
4138 
4139 	/* gpio */
4140 	btwrite(0x00, BT848_GPIO_REG_INP);
4141 	btwrite(0x00, BT848_GPIO_OUT_EN);
4142 	if (bttv_verbose)
4143 		bttv_gpio_tracking(btv,"init");
4144 
4145 	/* needs to be done before i2c is registered */
4146 	bttv_init_card1(btv);
4147 
4148 	/* register i2c + gpio */
4149 	init_bttv_i2c(btv);
4150 
4151 	/* some card-specific stuff (needs working i2c) */
4152 	bttv_init_card2(btv);
4153 	bttv_init_tuner(btv);
4154 	if (btv->tuner_type != TUNER_ABSENT) {
4155 		bttv_set_frequency(btv, &init_freq);
4156 		btv->radio_freq = 90500 * 16; /* 90.5Mhz default */
4157 	}
4158 	btv->std = V4L2_STD_PAL;
4159 	init_irqreg(btv);
4160 	if (!bttv_tvcards[btv->c.type].no_video)
4161 		v4l2_ctrl_handler_setup(hdl);
4162 	if (hdl->error) {
4163 		result = hdl->error;
4164 		goto fail2;
4165 	}
4166 	/* mute device */
4167 	audio_mute(btv, 1);
4168 
4169 	/* register video4linux + input */
4170 	if (!bttv_tvcards[btv->c.type].no_video) {
4171 		v4l2_ctrl_add_handler(&btv->radio_ctrl_handler, hdl,
4172 				v4l2_ctrl_radio_filter, false);
4173 		if (btv->radio_ctrl_handler.error) {
4174 			result = btv->radio_ctrl_handler.error;
4175 			goto fail2;
4176 		}
4177 		set_input(btv, 0, btv->tvnorm);
4178 		bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4179 		btv->crop[1] = btv->crop[0]; /* current = default */
4180 		disclaim_vbi_lines(btv);
4181 		disclaim_video_lines(btv);
4182 		bttv_register_video(btv);
4183 	}
4184 
4185 	/* add subdevices and autoload dvb-bt8xx if needed */
4186 	if (bttv_tvcards[btv->c.type].has_dvb) {
4187 		bttv_sub_add_device(&btv->c, "dvb");
4188 		request_modules(btv);
4189 	}
4190 
4191 	if (!disable_ir) {
4192 		init_bttv_i2c_ir(btv);
4193 		bttv_input_init(btv);
4194 	}
4195 
4196 	/* everything is fine */
4197 	bttv_num++;
4198 	return 0;
4199 
4200 fail2:
4201 	free_irq(btv->c.pci->irq,btv);
4202 
4203 fail1:
4204 	v4l2_ctrl_handler_free(&btv->ctrl_handler);
4205 	v4l2_ctrl_handler_free(&btv->radio_ctrl_handler);
4206 	v4l2_device_unregister(&btv->c.v4l2_dev);
4207 
4208 fail0:
4209 	if (btv->bt848_mmio)
4210 		iounmap(btv->bt848_mmio);
4211 	release_mem_region(pci_resource_start(btv->c.pci,0),
4212 			   pci_resource_len(btv->c.pci,0));
4213 	pci_disable_device(btv->c.pci);
4214 	return result;
4215 }
4216 
4217 static void bttv_remove(struct pci_dev *pci_dev)
4218 {
4219 	struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4220 	struct bttv *btv = to_bttv(v4l2_dev);
4221 
4222 	if (bttv_verbose)
4223 		pr_info("%d: unloading\n", btv->c.nr);
4224 
4225 	if (bttv_tvcards[btv->c.type].has_dvb)
4226 		flush_request_modules(btv);
4227 
4228 	/* shutdown everything (DMA+IRQs) */
4229 	btand(~15, BT848_GPIO_DMA_CTL);
4230 	btwrite(0, BT848_INT_MASK);
4231 	btwrite(~0x0, BT848_INT_STAT);
4232 	btwrite(0x0, BT848_GPIO_OUT_EN);
4233 	if (bttv_gpio)
4234 		bttv_gpio_tracking(btv,"cleanup");
4235 
4236 	/* tell gpio modules we are leaving ... */
4237 	btv->shutdown=1;
4238 	bttv_input_fini(btv);
4239 	bttv_sub_del_devices(&btv->c);
4240 
4241 	/* unregister i2c_bus + input */
4242 	fini_bttv_i2c(btv);
4243 
4244 	/* unregister video4linux */
4245 	bttv_unregister_video(btv);
4246 
4247 	/* free allocated memory */
4248 	v4l2_ctrl_handler_free(&btv->ctrl_handler);
4249 	v4l2_ctrl_handler_free(&btv->radio_ctrl_handler);
4250 	btcx_riscmem_free(btv->c.pci,&btv->main);
4251 
4252 	/* free resources */
4253 	free_irq(btv->c.pci->irq,btv);
4254 	iounmap(btv->bt848_mmio);
4255 	release_mem_region(pci_resource_start(btv->c.pci,0),
4256 			   pci_resource_len(btv->c.pci,0));
4257 	pci_disable_device(btv->c.pci);
4258 
4259 	v4l2_device_unregister(&btv->c.v4l2_dev);
4260 	bttvs[btv->c.nr] = NULL;
4261 	kfree(btv);
4262 
4263 	return;
4264 }
4265 
4266 #ifdef CONFIG_PM
4267 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4268 {
4269 	struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4270 	struct bttv *btv = to_bttv(v4l2_dev);
4271 	struct bttv_buffer_set idle;
4272 	unsigned long flags;
4273 
4274 	dprintk("%d: suspend %d\n", btv->c.nr, state.event);
4275 
4276 	/* stop dma + irqs */
4277 	spin_lock_irqsave(&btv->s_lock,flags);
4278 	memset(&idle, 0, sizeof(idle));
4279 	btv->state.video = btv->curr;
4280 	btv->state.vbi   = btv->cvbi;
4281 	btv->state.loop_irq = btv->loop_irq;
4282 	btv->curr = idle;
4283 	btv->loop_irq = 0;
4284 	bttv_buffer_activate_video(btv, &idle);
4285 	bttv_buffer_activate_vbi(btv, NULL);
4286 	bttv_set_dma(btv, 0);
4287 	btwrite(0, BT848_INT_MASK);
4288 	spin_unlock_irqrestore(&btv->s_lock,flags);
4289 
4290 	/* save bt878 state */
4291 	btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4292 	btv->state.gpio_data   = gpio_read();
4293 
4294 	/* save pci state */
4295 	pci_save_state(pci_dev);
4296 	if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4297 		pci_disable_device(pci_dev);
4298 		btv->state.disabled = 1;
4299 	}
4300 	return 0;
4301 }
4302 
4303 static int bttv_resume(struct pci_dev *pci_dev)
4304 {
4305 	struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4306 	struct bttv *btv = to_bttv(v4l2_dev);
4307 	unsigned long flags;
4308 	int err;
4309 
4310 	dprintk("%d: resume\n", btv->c.nr);
4311 
4312 	/* restore pci state */
4313 	if (btv->state.disabled) {
4314 		err=pci_enable_device(pci_dev);
4315 		if (err) {
4316 			pr_warn("%d: Can't enable device\n", btv->c.nr);
4317 			return err;
4318 		}
4319 		btv->state.disabled = 0;
4320 	}
4321 	err=pci_set_power_state(pci_dev, PCI_D0);
4322 	if (err) {
4323 		pci_disable_device(pci_dev);
4324 		pr_warn("%d: Can't enable device\n", btv->c.nr);
4325 		btv->state.disabled = 1;
4326 		return err;
4327 	}
4328 
4329 	pci_restore_state(pci_dev);
4330 
4331 	/* restore bt878 state */
4332 	bttv_reinit_bt848(btv);
4333 	gpio_inout(0xffffff, btv->state.gpio_enable);
4334 	gpio_write(btv->state.gpio_data);
4335 
4336 	/* restart dma */
4337 	spin_lock_irqsave(&btv->s_lock,flags);
4338 	btv->curr = btv->state.video;
4339 	btv->cvbi = btv->state.vbi;
4340 	btv->loop_irq = btv->state.loop_irq;
4341 	bttv_buffer_activate_video(btv, &btv->curr);
4342 	bttv_buffer_activate_vbi(btv, btv->cvbi);
4343 	bttv_set_dma(btv, 0);
4344 	spin_unlock_irqrestore(&btv->s_lock,flags);
4345 	return 0;
4346 }
4347 #endif
4348 
4349 static const struct pci_device_id bttv_pci_tbl[] = {
4350 	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0},
4351 	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0},
4352 	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0},
4353 	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0},
4354 	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_FUSION879), 0},
4355 	{0,}
4356 };
4357 
4358 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4359 
4360 static struct pci_driver bttv_pci_driver = {
4361 	.name     = "bttv",
4362 	.id_table = bttv_pci_tbl,
4363 	.probe    = bttv_probe,
4364 	.remove   = bttv_remove,
4365 #ifdef CONFIG_PM
4366 	.suspend  = bttv_suspend,
4367 	.resume   = bttv_resume,
4368 #endif
4369 };
4370 
4371 static int __init bttv_init_module(void)
4372 {
4373 	int ret;
4374 
4375 	bttv_num = 0;
4376 
4377 	pr_info("driver version %s loaded\n", BTTV_VERSION);
4378 	if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4379 		gbuffers = 2;
4380 	if (gbufsize > BTTV_MAX_FBUF)
4381 		gbufsize = BTTV_MAX_FBUF;
4382 	gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4383 	if (bttv_verbose)
4384 		pr_info("using %d buffers with %dk (%d pages) each for capture\n",
4385 			gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4386 
4387 	bttv_check_chipset();
4388 
4389 	ret = bus_register(&bttv_sub_bus_type);
4390 	if (ret < 0) {
4391 		pr_warn("bus_register error: %d\n", ret);
4392 		return ret;
4393 	}
4394 	ret = pci_register_driver(&bttv_pci_driver);
4395 	if (ret < 0)
4396 		bus_unregister(&bttv_sub_bus_type);
4397 
4398 	return ret;
4399 }
4400 
4401 static void __exit bttv_cleanup_module(void)
4402 {
4403 	pci_unregister_driver(&bttv_pci_driver);
4404 	bus_unregister(&bttv_sub_bus_type);
4405 }
4406 
4407 module_init(bttv_init_module);
4408 module_exit(bttv_cleanup_module);
4409