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 
card_show(struct device * cd,struct device_attribute * attr,char * buf)173 static ssize_t card_show(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_RO(card);
181 
182 /* ----------------------------------------------------------------------- */
183 /* dvb auto-load setup                                                     */
184 #if defined(CONFIG_MODULES) && defined(MODULE)
request_module_async(struct work_struct * work)185 static void request_module_async(struct work_struct *work)
186 {
187 	request_module("dvb-bt8xx");
188 }
189 
request_modules(struct bttv * dev)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 
flush_request_modules(struct bttv * dev)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
check_alloc_btres_lock(struct bttv * btv,struct bttv_fh * fh,int bit)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
check_btres(struct bttv_fh * fh,int bit)701 int check_btres(struct bttv_fh *fh, int bit)
702 {
703 	return (fh->resources & bit);
704 }
705 
706 static
locked_btres(struct bttv * btv,int bit)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
disclaim_vbi_lines(struct bttv * btv)714 disclaim_vbi_lines(struct bttv *btv)
715 {
716 	btv->vbi_end = 0;
717 }
718 
719 /* Call with btv->lock down. */
720 static void
disclaim_video_lines(struct bttv * btv)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
free_btres_lock(struct bttv * btv,struct bttv_fh * fh,int bits)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 
set_pll_freq(struct bttv * btv,unsigned int fin,unsigned int fout)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 
set_pll(struct bttv * btv)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 */
bt848A_set_timing(struct bttv * btv)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 
bt848_bright(struct bttv * btv,int bright)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 
bt848_hue(struct bttv * btv,int hue)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 
bt848_contrast(struct bttv * btv,int cont)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 
bt848_sat(struct bttv * btv,int color)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
video_mux(struct bttv * btv,unsigned int input)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
audio_mux_gpio(struct bttv * btv,int input,int mute)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
audio_mute(struct bttv * btv,int mute)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
audio_input(struct bttv * btv,int input)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
bttv_crop_calc_limits(struct bttv_crop * c)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
bttv_crop_reset(struct bttv_crop * c,unsigned int norm)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
set_tvnorm(struct bttv * btv,unsigned int norm)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
set_input(struct bttv * btv,unsigned int input,unsigned int norm)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 
init_irqreg(struct bttv * btv)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 
init_bt848(struct bttv * btv)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 
bttv_reinit_bt848(struct bttv * btv)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 
bttv_s_ctrl(struct v4l2_ctrl * c)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 
bttv_gpio_tracking(struct bttv * btv,char * comment)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 
bttv_field_count(struct bttv * btv)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*
format_by_fourcc(int fourcc)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
bttv_switch_overlay(struct bttv * btv,struct bttv_fh * fh,struct bttv_buffer * new)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 
bttv_prepare_buffer(struct videobuf_queue * q,struct bttv * btv,struct bttv_buffer * buf,const struct bttv_format * fmt,unsigned int width,unsigned int height,enum v4l2_field field)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
buffer_setup(struct videobuf_queue * q,unsigned int * count,unsigned int * size)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
buffer_prepare(struct videobuf_queue * q,struct videobuf_buffer * vb,enum v4l2_field field)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
buffer_queue(struct videobuf_queue * q,struct videobuf_buffer * vb)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 
buffer_release(struct videobuf_queue * q,struct videobuf_buffer * vb)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 
radio_enable(struct bttv * btv)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 
bttv_s_std(struct file * file,void * priv,v4l2_std_id id)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 
bttv_g_std(struct file * file,void * priv,v4l2_std_id * id)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 
bttv_querystd(struct file * file,void * f,v4l2_std_id * id)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 
bttv_enum_input(struct file * file,void * priv,struct v4l2_input * i)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 
bttv_g_input(struct file * file,void * priv,unsigned int * i)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 
bttv_s_input(struct file * file,void * priv,unsigned int i)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 
bttv_s_tuner(struct file * file,void * priv,const struct v4l2_tuner * t)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 
bttv_g_frequency(struct file * file,void * priv,struct v4l2_frequency * f)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 
bttv_set_frequency(struct bttv * btv,const struct v4l2_frequency * f)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 
bttv_s_frequency(struct file * file,void * priv,const struct v4l2_frequency * f)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 
bttv_log_status(struct file * file,void * f)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
bttv_g_register(struct file * file,void * f,struct v4l2_dbg_register * reg)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 
bttv_s_register(struct file * file,void * f,const struct v4l2_dbg_register * reg)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
bttv_crop_adjust(struct bttv_crop * c,const struct v4l2_rect * b,__s32 width,__s32 height,enum v4l2_field field)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
limit_scaled_size_lock(struct bttv_fh * fh,__s32 * width,__s32 * height,enum v4l2_field field,unsigned int width_mask,unsigned int width_bias,int adjust_size,int adjust_crop)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
verify_window_lock(struct bttv_fh * fh,struct v4l2_window * win,int adjust_size,int adjust_crop)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 
2062 	if (win->w.width < 48)
2063 		win->w.width = 48;
2064 	if (win->w.height < 32)
2065 		win->w.height = 32;
2066 	if (win->clipcount > 2048)
2067 		win->clipcount = 2048;
2068 
2069 	win->chromakey = 0;
2070 	win->global_alpha = 0;
2071 	field = win->field;
2072 
2073 	switch (field) {
2074 	case V4L2_FIELD_TOP:
2075 	case V4L2_FIELD_BOTTOM:
2076 	case V4L2_FIELD_INTERLACED:
2077 		break;
2078 	default:
2079 		field = V4L2_FIELD_ANY;
2080 		break;
2081 	}
2082 	if (V4L2_FIELD_ANY == field) {
2083 		__s32 height2;
2084 
2085 		height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2086 		field = (win->w.height > height2)
2087 			? V4L2_FIELD_INTERLACED
2088 			: V4L2_FIELD_TOP;
2089 	}
2090 	win->field = field;
2091 
2092 	if (NULL == fh->ovfmt)
2093 		return -EINVAL;
2094 	/* 4-byte alignment. */
2095 	width_mask = ~0;
2096 	switch (fh->ovfmt->depth) {
2097 	case 8:
2098 	case 24:
2099 		width_mask = ~3;
2100 		break;
2101 	case 16:
2102 		width_mask = ~1;
2103 		break;
2104 	case 32:
2105 		break;
2106 	default:
2107 		BUG();
2108 	}
2109 
2110 	win->w.width -= win->w.left & ~width_mask;
2111 	win->w.left = (win->w.left - width_mask - 1) & width_mask;
2112 
2113 	return limit_scaled_size_lock(fh, &win->w.width, &win->w.height,
2114 				      field, width_mask,
2115 				      /* width_bias: round down */ 0,
2116 				      adjust_size, adjust_crop);
2117 }
2118 
setup_window_lock(struct bttv_fh * fh,struct bttv * btv,struct v4l2_window * win,int fixup)2119 static int setup_window_lock(struct bttv_fh *fh, struct bttv *btv,
2120 			struct v4l2_window *win, int fixup)
2121 {
2122 	struct v4l2_clip *clips = NULL;
2123 	int n,size,retval = 0;
2124 
2125 	if (NULL == fh->ovfmt)
2126 		return -EINVAL;
2127 	if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2128 		return -EINVAL;
2129 	retval = verify_window_lock(fh, win,
2130 			       /* adjust_size */ fixup,
2131 			       /* adjust_crop */ fixup);
2132 	if (0 != retval)
2133 		return retval;
2134 
2135 	/* copy clips  --  luckily v4l1 + v4l2 are binary
2136 	   compatible here ...*/
2137 	n = win->clipcount;
2138 	size = sizeof(*clips)*(n+4);
2139 	clips = kmalloc(size,GFP_KERNEL);
2140 	if (NULL == clips)
2141 		return -ENOMEM;
2142 	if (n > 0)
2143 		memcpy(clips, win->clips, sizeof(struct v4l2_clip) * n);
2144 
2145 	/* clip against screen */
2146 	if (NULL != btv->fbuf.base)
2147 		n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2148 				      &win->w, clips, n);
2149 	btcx_sort_clips(clips,n);
2150 
2151 	/* 4-byte alignments */
2152 	switch (fh->ovfmt->depth) {
2153 	case 8:
2154 	case 24:
2155 		btcx_align(&win->w, clips, n, 3);
2156 		break;
2157 	case 16:
2158 		btcx_align(&win->w, clips, n, 1);
2159 		break;
2160 	case 32:
2161 		/* no alignment fixups needed */
2162 		break;
2163 	default:
2164 		BUG();
2165 	}
2166 
2167 	kfree(fh->ov.clips);
2168 	fh->ov.clips    = clips;
2169 	fh->ov.nclips   = n;
2170 
2171 	fh->ov.w        = win->w;
2172 	fh->ov.field    = win->field;
2173 	fh->ov.setup_ok = 1;
2174 
2175 	btv->init.ov.w.width   = win->w.width;
2176 	btv->init.ov.w.height  = win->w.height;
2177 	btv->init.ov.field     = win->field;
2178 
2179 	/* update overlay if needed */
2180 	retval = 0;
2181 	if (check_btres(fh, RESOURCE_OVERLAY)) {
2182 		struct bttv_buffer *new;
2183 
2184 		new = videobuf_sg_alloc(sizeof(*new));
2185 		new->crop = btv->crop[!!fh->do_crop].rect;
2186 		bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2187 		retval = bttv_switch_overlay(btv,fh,new);
2188 	}
2189 	return retval;
2190 }
2191 
2192 /* ----------------------------------------------------------------------- */
2193 
bttv_queue(struct bttv_fh * fh)2194 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2195 {
2196 	struct videobuf_queue* q = NULL;
2197 
2198 	switch (fh->type) {
2199 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2200 		q = &fh->cap;
2201 		break;
2202 	case V4L2_BUF_TYPE_VBI_CAPTURE:
2203 		q = &fh->vbi;
2204 		break;
2205 	default:
2206 		BUG();
2207 	}
2208 	return q;
2209 }
2210 
bttv_resource(struct bttv_fh * fh)2211 static int bttv_resource(struct bttv_fh *fh)
2212 {
2213 	int res = 0;
2214 
2215 	switch (fh->type) {
2216 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2217 		res = RESOURCE_VIDEO_STREAM;
2218 		break;
2219 	case V4L2_BUF_TYPE_VBI_CAPTURE:
2220 		res = RESOURCE_VBI;
2221 		break;
2222 	default:
2223 		BUG();
2224 	}
2225 	return res;
2226 }
2227 
bttv_switch_type(struct bttv_fh * fh,enum v4l2_buf_type type)2228 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2229 {
2230 	struct videobuf_queue *q = bttv_queue(fh);
2231 	int res = bttv_resource(fh);
2232 
2233 	if (check_btres(fh,res))
2234 		return -EBUSY;
2235 	if (videobuf_queue_is_busy(q))
2236 		return -EBUSY;
2237 	fh->type = type;
2238 	return 0;
2239 }
2240 
2241 static void
pix_format_set_size(struct v4l2_pix_format * f,const struct bttv_format * fmt,unsigned int width,unsigned int height)2242 pix_format_set_size     (struct v4l2_pix_format *       f,
2243 			 const struct bttv_format *     fmt,
2244 			 unsigned int                   width,
2245 			 unsigned int                   height)
2246 {
2247 	f->width = width;
2248 	f->height = height;
2249 
2250 	if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2251 		f->bytesperline = width; /* Y plane */
2252 		f->sizeimage = (width * height * fmt->depth) >> 3;
2253 	} else {
2254 		f->bytesperline = (width * fmt->depth) >> 3;
2255 		f->sizeimage = height * f->bytesperline;
2256 	}
2257 }
2258 
bttv_g_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)2259 static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
2260 					struct v4l2_format *f)
2261 {
2262 	struct bttv_fh *fh  = priv;
2263 
2264 	pix_format_set_size(&f->fmt.pix, fh->fmt,
2265 				fh->width, fh->height);
2266 	f->fmt.pix.field        = fh->cap.field;
2267 	f->fmt.pix.pixelformat  = fh->fmt->fourcc;
2268 	f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
2269 
2270 	return 0;
2271 }
2272 
bttv_g_fmt_vid_overlay(struct file * file,void * priv,struct v4l2_format * f)2273 static int bttv_g_fmt_vid_overlay(struct file *file, void *priv,
2274 					struct v4l2_format *f)
2275 {
2276 	struct bttv_fh *fh  = priv;
2277 
2278 	f->fmt.win.w     = fh->ov.w;
2279 	f->fmt.win.field = fh->ov.field;
2280 
2281 	return 0;
2282 }
2283 
bttv_get_width_mask_vid_cap(const struct bttv_format * fmt,unsigned int * width_mask,unsigned int * width_bias)2284 static void bttv_get_width_mask_vid_cap(const struct bttv_format *fmt,
2285 					unsigned int *width_mask,
2286 					unsigned int *width_bias)
2287 {
2288 	if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2289 		*width_mask = ~15; /* width must be a multiple of 16 pixels */
2290 		*width_bias = 8;   /* nearest */
2291 	} else {
2292 		*width_mask = ~3; /* width must be a multiple of 4 pixels */
2293 		*width_bias = 2;  /* nearest */
2294 	}
2295 }
2296 
bttv_try_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)2297 static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
2298 						struct v4l2_format *f)
2299 {
2300 	const struct bttv_format *fmt;
2301 	struct bttv_fh *fh = priv;
2302 	struct bttv *btv = fh->btv;
2303 	enum v4l2_field field;
2304 	__s32 width, height;
2305 	__s32 height2;
2306 	unsigned int width_mask, width_bias;
2307 	int rc;
2308 
2309 	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2310 	if (NULL == fmt)
2311 		return -EINVAL;
2312 
2313 	field = f->fmt.pix.field;
2314 
2315 	switch (field) {
2316 	case V4L2_FIELD_TOP:
2317 	case V4L2_FIELD_BOTTOM:
2318 	case V4L2_FIELD_ALTERNATE:
2319 	case V4L2_FIELD_INTERLACED:
2320 		break;
2321 	case V4L2_FIELD_SEQ_BT:
2322 	case V4L2_FIELD_SEQ_TB:
2323 		if (!(fmt->flags & FORMAT_FLAGS_PLANAR)) {
2324 			field = V4L2_FIELD_SEQ_TB;
2325 			break;
2326 		}
2327 		fallthrough;
2328 	default: /* FIELD_ANY case */
2329 		height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2330 		field = (f->fmt.pix.height > height2)
2331 			? V4L2_FIELD_INTERLACED
2332 			: V4L2_FIELD_BOTTOM;
2333 		break;
2334 	}
2335 
2336 	width = f->fmt.pix.width;
2337 	height = f->fmt.pix.height;
2338 
2339 	bttv_get_width_mask_vid_cap(fmt, &width_mask, &width_bias);
2340 	rc = limit_scaled_size_lock(fh, &width, &height, field,
2341 			       width_mask, width_bias,
2342 			       /* adjust_size */ 1,
2343 			       /* adjust_crop */ 0);
2344 	if (0 != rc)
2345 		return rc;
2346 
2347 	/* update data for the application */
2348 	f->fmt.pix.field = field;
2349 	pix_format_set_size(&f->fmt.pix, fmt, width, height);
2350 	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
2351 
2352 	return 0;
2353 }
2354 
bttv_try_fmt_vid_overlay(struct file * file,void * priv,struct v4l2_format * f)2355 static int bttv_try_fmt_vid_overlay(struct file *file, void *priv,
2356 						struct v4l2_format *f)
2357 {
2358 	struct bttv_fh *fh = priv;
2359 
2360 	verify_window_lock(fh, &f->fmt.win,
2361 			/* adjust_size */ 1,
2362 			/* adjust_crop */ 0);
2363 	return 0;
2364 }
2365 
bttv_s_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)2366 static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2367 				struct v4l2_format *f)
2368 {
2369 	int retval;
2370 	const struct bttv_format *fmt;
2371 	struct bttv_fh *fh = priv;
2372 	struct bttv *btv = fh->btv;
2373 	__s32 width, height;
2374 	unsigned int width_mask, width_bias;
2375 	enum v4l2_field field;
2376 
2377 	retval = bttv_switch_type(fh, f->type);
2378 	if (0 != retval)
2379 		return retval;
2380 
2381 	retval = bttv_try_fmt_vid_cap(file, priv, f);
2382 	if (0 != retval)
2383 		return retval;
2384 
2385 	width = f->fmt.pix.width;
2386 	height = f->fmt.pix.height;
2387 	field = f->fmt.pix.field;
2388 
2389 	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2390 	bttv_get_width_mask_vid_cap(fmt, &width_mask, &width_bias);
2391 	retval = limit_scaled_size_lock(fh, &width, &height, f->fmt.pix.field,
2392 			       width_mask, width_bias,
2393 			       /* adjust_size */ 1,
2394 			       /* adjust_crop */ 1);
2395 	if (0 != retval)
2396 		return retval;
2397 
2398 	f->fmt.pix.field = field;
2399 
2400 	/* update our state information */
2401 	fh->fmt              = fmt;
2402 	fh->cap.field        = f->fmt.pix.field;
2403 	fh->cap.last         = V4L2_FIELD_NONE;
2404 	fh->width            = f->fmt.pix.width;
2405 	fh->height           = f->fmt.pix.height;
2406 	btv->init.fmt        = fmt;
2407 	btv->init.width      = f->fmt.pix.width;
2408 	btv->init.height     = f->fmt.pix.height;
2409 
2410 	return 0;
2411 }
2412 
bttv_s_fmt_vid_overlay(struct file * file,void * priv,struct v4l2_format * f)2413 static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
2414 				struct v4l2_format *f)
2415 {
2416 	struct bttv_fh *fh = priv;
2417 	struct bttv *btv = fh->btv;
2418 
2419 	if (no_overlay > 0) {
2420 		pr_err("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2421 		return -EINVAL;
2422 	}
2423 
2424 	return setup_window_lock(fh, btv, &f->fmt.win, 1);
2425 }
2426 
bttv_querycap(struct file * file,void * priv,struct v4l2_capability * cap)2427 static int bttv_querycap(struct file *file, void  *priv,
2428 				struct v4l2_capability *cap)
2429 {
2430 	struct bttv_fh *fh = priv;
2431 	struct bttv *btv = fh->btv;
2432 
2433 	if (0 == v4l2)
2434 		return -EINVAL;
2435 
2436 	strscpy(cap->driver, "bttv", sizeof(cap->driver));
2437 	strscpy(cap->card, btv->video_dev.name, sizeof(cap->card));
2438 	cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
2439 			    V4L2_CAP_STREAMING | V4L2_CAP_DEVICE_CAPS;
2440 	if (no_overlay <= 0)
2441 		cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2442 	if (video_is_registered(&btv->vbi_dev))
2443 		cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
2444 	if (video_is_registered(&btv->radio_dev)) {
2445 		cap->capabilities |= V4L2_CAP_RADIO;
2446 		if (btv->has_tea575x)
2447 			cap->capabilities |= V4L2_CAP_HW_FREQ_SEEK;
2448 	}
2449 
2450 	/*
2451 	 * No need to lock here: those vars are initialized during board
2452 	 * probe and remains untouched during the rest of the driver lifecycle
2453 	 */
2454 	if (btv->has_saa6588)
2455 		cap->capabilities |= V4L2_CAP_RDS_CAPTURE;
2456 	if (btv->tuner_type != TUNER_ABSENT)
2457 		cap->capabilities |= V4L2_CAP_TUNER;
2458 	return 0;
2459 }
2460 
bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc * f)2461 static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f)
2462 {
2463 	int index = -1, i;
2464 
2465 	for (i = 0; i < FORMATS; i++) {
2466 		if (formats[i].fourcc != -1)
2467 			index++;
2468 		if ((unsigned int)index == f->index)
2469 			break;
2470 	}
2471 	if (FORMATS == i)
2472 		return -EINVAL;
2473 
2474 	f->pixelformat = formats[i].fourcc;
2475 
2476 	return i;
2477 }
2478 
bttv_enum_fmt_vid_cap(struct file * file,void * priv,struct v4l2_fmtdesc * f)2479 static int bttv_enum_fmt_vid_cap(struct file *file, void  *priv,
2480 				struct v4l2_fmtdesc *f)
2481 {
2482 	int rc = bttv_enum_fmt_cap_ovr(f);
2483 
2484 	if (rc < 0)
2485 		return rc;
2486 
2487 	return 0;
2488 }
2489 
bttv_enum_fmt_vid_overlay(struct file * file,void * priv,struct v4l2_fmtdesc * f)2490 static int bttv_enum_fmt_vid_overlay(struct file *file, void  *priv,
2491 					struct v4l2_fmtdesc *f)
2492 {
2493 	int rc;
2494 
2495 	if (no_overlay > 0) {
2496 		pr_err("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2497 		return -EINVAL;
2498 	}
2499 
2500 	rc = bttv_enum_fmt_cap_ovr(f);
2501 
2502 	if (rc < 0)
2503 		return rc;
2504 
2505 	if (!(formats[rc].flags & FORMAT_FLAGS_PACKED))
2506 		return -EINVAL;
2507 
2508 	return 0;
2509 }
2510 
bttv_g_fbuf(struct file * file,void * f,struct v4l2_framebuffer * fb)2511 static int bttv_g_fbuf(struct file *file, void *f,
2512 				struct v4l2_framebuffer *fb)
2513 {
2514 	struct bttv_fh *fh = f;
2515 	struct bttv *btv = fh->btv;
2516 
2517 	*fb = btv->fbuf;
2518 	fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2519 	fb->flags = V4L2_FBUF_FLAG_PRIMARY;
2520 	if (fh->ovfmt)
2521 		fb->fmt.pixelformat  = fh->ovfmt->fourcc;
2522 	return 0;
2523 }
2524 
bttv_overlay(struct file * file,void * f,unsigned int on)2525 static int bttv_overlay(struct file *file, void *f, unsigned int on)
2526 {
2527 	struct bttv_fh *fh = f;
2528 	struct bttv *btv = fh->btv;
2529 	struct bttv_buffer *new;
2530 	int retval = 0;
2531 
2532 	if (on) {
2533 		/* verify args */
2534 		if (unlikely(!btv->fbuf.base)) {
2535 			return -EINVAL;
2536 		}
2537 		if (unlikely(!fh->ov.setup_ok)) {
2538 			dprintk("%d: overlay: !setup_ok\n", btv->c.nr);
2539 			retval = -EINVAL;
2540 		}
2541 		if (retval)
2542 			return retval;
2543 	}
2544 
2545 	if (!check_alloc_btres_lock(btv, fh, RESOURCE_OVERLAY))
2546 		return -EBUSY;
2547 
2548 	if (on) {
2549 		fh->ov.tvnorm = btv->tvnorm;
2550 		new = videobuf_sg_alloc(sizeof(*new));
2551 		new->crop = btv->crop[!!fh->do_crop].rect;
2552 		bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2553 	} else {
2554 		new = NULL;
2555 	}
2556 
2557 	/* switch over */
2558 	retval = bttv_switch_overlay(btv, fh, new);
2559 	return retval;
2560 }
2561 
bttv_s_fbuf(struct file * file,void * f,const struct v4l2_framebuffer * fb)2562 static int bttv_s_fbuf(struct file *file, void *f,
2563 				const struct v4l2_framebuffer *fb)
2564 {
2565 	struct bttv_fh *fh = f;
2566 	struct bttv *btv = fh->btv;
2567 	const struct bttv_format *fmt;
2568 	int retval;
2569 
2570 	if (!capable(CAP_SYS_ADMIN) &&
2571 		!capable(CAP_SYS_RAWIO))
2572 		return -EPERM;
2573 
2574 	/* check args */
2575 	fmt = format_by_fourcc(fb->fmt.pixelformat);
2576 	if (NULL == fmt)
2577 		return -EINVAL;
2578 	if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2579 		return -EINVAL;
2580 
2581 	retval = -EINVAL;
2582 	if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2583 		__s32 width = fb->fmt.width;
2584 		__s32 height = fb->fmt.height;
2585 
2586 		retval = limit_scaled_size_lock(fh, &width, &height,
2587 					   V4L2_FIELD_INTERLACED,
2588 					   /* width_mask */ ~3,
2589 					   /* width_bias */ 2,
2590 					   /* adjust_size */ 0,
2591 					   /* adjust_crop */ 0);
2592 		if (0 != retval)
2593 			return retval;
2594 	}
2595 
2596 	/* ok, accept it */
2597 	btv->fbuf.base       = fb->base;
2598 	btv->fbuf.fmt.width  = fb->fmt.width;
2599 	btv->fbuf.fmt.height = fb->fmt.height;
2600 	if (0 != fb->fmt.bytesperline)
2601 		btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2602 	else
2603 		btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2604 
2605 	retval = 0;
2606 	fh->ovfmt = fmt;
2607 	btv->init.ovfmt = fmt;
2608 	if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2609 		fh->ov.w.left   = 0;
2610 		fh->ov.w.top    = 0;
2611 		fh->ov.w.width  = fb->fmt.width;
2612 		fh->ov.w.height = fb->fmt.height;
2613 		btv->init.ov.w.width  = fb->fmt.width;
2614 		btv->init.ov.w.height = fb->fmt.height;
2615 
2616 		kfree(fh->ov.clips);
2617 		fh->ov.clips = NULL;
2618 		fh->ov.nclips = 0;
2619 
2620 		if (check_btres(fh, RESOURCE_OVERLAY)) {
2621 			struct bttv_buffer *new;
2622 
2623 			new = videobuf_sg_alloc(sizeof(*new));
2624 			new->crop = btv->crop[!!fh->do_crop].rect;
2625 			bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2626 			retval = bttv_switch_overlay(btv, fh, new);
2627 		}
2628 	}
2629 	return retval;
2630 }
2631 
bttv_reqbufs(struct file * file,void * priv,struct v4l2_requestbuffers * p)2632 static int bttv_reqbufs(struct file *file, void *priv,
2633 				struct v4l2_requestbuffers *p)
2634 {
2635 	struct bttv_fh *fh = priv;
2636 	return videobuf_reqbufs(bttv_queue(fh), p);
2637 }
2638 
bttv_querybuf(struct file * file,void * priv,struct v4l2_buffer * b)2639 static int bttv_querybuf(struct file *file, void *priv,
2640 				struct v4l2_buffer *b)
2641 {
2642 	struct bttv_fh *fh = priv;
2643 	return videobuf_querybuf(bttv_queue(fh), b);
2644 }
2645 
bttv_qbuf(struct file * file,void * priv,struct v4l2_buffer * b)2646 static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2647 {
2648 	struct bttv_fh *fh = priv;
2649 	struct bttv *btv = fh->btv;
2650 	int res = bttv_resource(fh);
2651 
2652 	if (!check_alloc_btres_lock(btv, fh, res))
2653 		return -EBUSY;
2654 
2655 	return videobuf_qbuf(bttv_queue(fh), b);
2656 }
2657 
bttv_dqbuf(struct file * file,void * priv,struct v4l2_buffer * b)2658 static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2659 {
2660 	struct bttv_fh *fh = priv;
2661 	return videobuf_dqbuf(bttv_queue(fh), b,
2662 			file->f_flags & O_NONBLOCK);
2663 }
2664 
bttv_streamon(struct file * file,void * priv,enum v4l2_buf_type type)2665 static int bttv_streamon(struct file *file, void *priv,
2666 					enum v4l2_buf_type type)
2667 {
2668 	struct bttv_fh *fh = priv;
2669 	struct bttv *btv = fh->btv;
2670 	int res = bttv_resource(fh);
2671 
2672 	if (!check_alloc_btres_lock(btv, fh, res))
2673 		return -EBUSY;
2674 	return videobuf_streamon(bttv_queue(fh));
2675 }
2676 
2677 
bttv_streamoff(struct file * file,void * priv,enum v4l2_buf_type type)2678 static int bttv_streamoff(struct file *file, void *priv,
2679 					enum v4l2_buf_type type)
2680 {
2681 	struct bttv_fh *fh = priv;
2682 	struct bttv *btv = fh->btv;
2683 	int retval;
2684 	int res = bttv_resource(fh);
2685 
2686 
2687 	retval = videobuf_streamoff(bttv_queue(fh));
2688 	if (retval < 0)
2689 		return retval;
2690 	free_btres_lock(btv, fh, res);
2691 	return 0;
2692 }
2693 
bttv_g_parm(struct file * file,void * f,struct v4l2_streamparm * parm)2694 static int bttv_g_parm(struct file *file, void *f,
2695 				struct v4l2_streamparm *parm)
2696 {
2697 	struct bttv_fh *fh = f;
2698 	struct bttv *btv = fh->btv;
2699 
2700 	if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2701 		return -EINVAL;
2702 	parm->parm.capture.readbuffers = gbuffers;
2703 	v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id,
2704 				    &parm->parm.capture.timeperframe);
2705 
2706 	return 0;
2707 }
2708 
bttv_g_tuner(struct file * file,void * priv,struct v4l2_tuner * t)2709 static int bttv_g_tuner(struct file *file, void *priv,
2710 				struct v4l2_tuner *t)
2711 {
2712 	struct bttv_fh *fh = priv;
2713 	struct bttv *btv = fh->btv;
2714 
2715 	if (0 != t->index)
2716 		return -EINVAL;
2717 
2718 	t->rxsubchans = V4L2_TUNER_SUB_MONO;
2719 	t->capability = V4L2_TUNER_CAP_NORM;
2720 	bttv_call_all(btv, tuner, g_tuner, t);
2721 	strscpy(t->name, "Television", sizeof(t->name));
2722 	t->type       = V4L2_TUNER_ANALOG_TV;
2723 	if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2724 		t->signal = 0xffff;
2725 
2726 	if (btv->audio_mode_gpio)
2727 		btv->audio_mode_gpio(btv, t, 0);
2728 
2729 	return 0;
2730 }
2731 
bttv_g_pixelaspect(struct file * file,void * priv,int type,struct v4l2_fract * f)2732 static int bttv_g_pixelaspect(struct file *file, void *priv,
2733 			      int type, struct v4l2_fract *f)
2734 {
2735 	struct bttv_fh *fh = priv;
2736 	struct bttv *btv = fh->btv;
2737 
2738 	if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2739 		return -EINVAL;
2740 
2741 	/* defrect and bounds are set via g_selection */
2742 	*f = bttv_tvnorms[btv->tvnorm].cropcap.pixelaspect;
2743 	return 0;
2744 }
2745 
bttv_g_selection(struct file * file,void * f,struct v4l2_selection * sel)2746 static int bttv_g_selection(struct file *file, void *f, struct v4l2_selection *sel)
2747 {
2748 	struct bttv_fh *fh = f;
2749 	struct bttv *btv = fh->btv;
2750 
2751 	if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2752 	    sel->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2753 		return -EINVAL;
2754 
2755 	switch (sel->target) {
2756 	case V4L2_SEL_TGT_CROP:
2757 		/*
2758 		 * No fh->do_crop = 1; because btv->crop[1] may be
2759 		 * inconsistent with fh->width or fh->height and apps
2760 		 * do not expect a change here.
2761 		 */
2762 		sel->r = btv->crop[!!fh->do_crop].rect;
2763 		break;
2764 	case V4L2_SEL_TGT_CROP_DEFAULT:
2765 		sel->r = bttv_tvnorms[btv->tvnorm].cropcap.defrect;
2766 		break;
2767 	case V4L2_SEL_TGT_CROP_BOUNDS:
2768 		sel->r = bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2769 		break;
2770 	default:
2771 		return -EINVAL;
2772 	}
2773 
2774 	return 0;
2775 }
2776 
bttv_s_selection(struct file * file,void * f,struct v4l2_selection * sel)2777 static int bttv_s_selection(struct file *file, void *f, struct v4l2_selection *sel)
2778 {
2779 	struct bttv_fh *fh = f;
2780 	struct bttv *btv = fh->btv;
2781 	const struct v4l2_rect *b;
2782 	int retval;
2783 	struct bttv_crop c;
2784 	__s32 b_left;
2785 	__s32 b_top;
2786 	__s32 b_right;
2787 	__s32 b_bottom;
2788 
2789 	if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2790 	    sel->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2791 		return -EINVAL;
2792 
2793 	if (sel->target != V4L2_SEL_TGT_CROP)
2794 		return -EINVAL;
2795 
2796 	/* Make sure tvnorm, vbi_end and the current cropping
2797 	   parameters remain consistent until we're done. Note
2798 	   read() may change vbi_end in check_alloc_btres_lock(). */
2799 	retval = -EBUSY;
2800 
2801 	if (locked_btres(fh->btv, VIDEO_RESOURCES)) {
2802 		return retval;
2803 	}
2804 
2805 	b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2806 
2807 	b_left = b->left;
2808 	b_right = b_left + b->width;
2809 	b_bottom = b->top + b->height;
2810 
2811 	b_top = max(b->top, btv->vbi_end);
2812 	if (b_top + 32 >= b_bottom) {
2813 		return retval;
2814 	}
2815 
2816 	/* Min. scaled size 48 x 32. */
2817 	c.rect.left = clamp_t(s32, sel->r.left, b_left, b_right - 48);
2818 	c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
2819 
2820 	c.rect.width = clamp_t(s32, sel->r.width,
2821 			     48, b_right - c.rect.left);
2822 
2823 	c.rect.top = clamp_t(s32, sel->r.top, b_top, b_bottom - 32);
2824 	/* Top and height must be a multiple of two. */
2825 	c.rect.top = (c.rect.top + 1) & ~1;
2826 
2827 	c.rect.height = clamp_t(s32, sel->r.height,
2828 			      32, b_bottom - c.rect.top);
2829 	c.rect.height = (c.rect.height + 1) & ~1;
2830 
2831 	bttv_crop_calc_limits(&c);
2832 
2833 	sel->r = c.rect;
2834 
2835 	btv->crop[1] = c;
2836 
2837 	fh->do_crop = 1;
2838 
2839 	if (fh->width < c.min_scaled_width) {
2840 		fh->width = c.min_scaled_width;
2841 		btv->init.width = c.min_scaled_width;
2842 	} else if (fh->width > c.max_scaled_width) {
2843 		fh->width = c.max_scaled_width;
2844 		btv->init.width = c.max_scaled_width;
2845 	}
2846 
2847 	if (fh->height < c.min_scaled_height) {
2848 		fh->height = c.min_scaled_height;
2849 		btv->init.height = c.min_scaled_height;
2850 	} else if (fh->height > c.max_scaled_height) {
2851 		fh->height = c.max_scaled_height;
2852 		btv->init.height = c.max_scaled_height;
2853 	}
2854 
2855 	return 0;
2856 }
2857 
bttv_read(struct file * file,char __user * data,size_t count,loff_t * ppos)2858 static ssize_t bttv_read(struct file *file, char __user *data,
2859 			 size_t count, loff_t *ppos)
2860 {
2861 	struct bttv_fh *fh = file->private_data;
2862 	int retval = 0;
2863 
2864 	if (fh->btv->errors)
2865 		bttv_reinit_bt848(fh->btv);
2866 	dprintk("%d: read count=%d type=%s\n",
2867 		fh->btv->c.nr, (int)count, v4l2_type_names[fh->type]);
2868 
2869 	switch (fh->type) {
2870 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2871 		if (!check_alloc_btres_lock(fh->btv, fh, RESOURCE_VIDEO_READ)) {
2872 			/* VIDEO_READ in use by another fh,
2873 			   or VIDEO_STREAM by any fh. */
2874 			return -EBUSY;
2875 		}
2876 		retval = videobuf_read_one(&fh->cap, data, count, ppos,
2877 					   file->f_flags & O_NONBLOCK);
2878 		free_btres_lock(fh->btv, fh, RESOURCE_VIDEO_READ);
2879 		break;
2880 	case V4L2_BUF_TYPE_VBI_CAPTURE:
2881 		if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI))
2882 			return -EBUSY;
2883 		retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
2884 					      file->f_flags & O_NONBLOCK);
2885 		break;
2886 	default:
2887 		BUG();
2888 	}
2889 	return retval;
2890 }
2891 
bttv_poll(struct file * file,poll_table * wait)2892 static __poll_t bttv_poll(struct file *file, poll_table *wait)
2893 {
2894 	struct bttv_fh *fh = file->private_data;
2895 	struct bttv_buffer *buf;
2896 	enum v4l2_field field;
2897 	__poll_t rc = 0;
2898 	__poll_t req_events = poll_requested_events(wait);
2899 
2900 	if (v4l2_event_pending(&fh->fh))
2901 		rc = EPOLLPRI;
2902 	else if (req_events & EPOLLPRI)
2903 		poll_wait(file, &fh->fh.wait, wait);
2904 
2905 	if (!(req_events & (EPOLLIN | EPOLLRDNORM)))
2906 		return rc;
2907 
2908 	if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
2909 		if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI))
2910 			return rc | EPOLLERR;
2911 		return rc | videobuf_poll_stream(file, &fh->vbi, wait);
2912 	}
2913 
2914 	if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
2915 		/* streaming capture */
2916 		if (list_empty(&fh->cap.stream))
2917 			return rc | EPOLLERR;
2918 		buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
2919 	} else {
2920 		/* read() capture */
2921 		if (NULL == fh->cap.read_buf) {
2922 			/* need to capture a new frame */
2923 			if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
2924 				return rc | EPOLLERR;
2925 			fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize);
2926 			if (NULL == fh->cap.read_buf)
2927 				return rc | EPOLLERR;
2928 			fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
2929 			field = videobuf_next_field(&fh->cap);
2930 			if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
2931 				kfree (fh->cap.read_buf);
2932 				fh->cap.read_buf = NULL;
2933 				return rc | EPOLLERR;
2934 			}
2935 			fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
2936 			fh->cap.read_off = 0;
2937 		}
2938 		buf = (struct bttv_buffer*)fh->cap.read_buf;
2939 	}
2940 
2941 	poll_wait(file, &buf->vb.done, wait);
2942 	if (buf->vb.state == VIDEOBUF_DONE ||
2943 	    buf->vb.state == VIDEOBUF_ERROR)
2944 		rc = rc | EPOLLIN|EPOLLRDNORM;
2945 	return rc;
2946 }
2947 
bttv_open(struct file * file)2948 static int bttv_open(struct file *file)
2949 {
2950 	struct video_device *vdev = video_devdata(file);
2951 	struct bttv *btv = video_drvdata(file);
2952 	struct bttv_fh *fh;
2953 	enum v4l2_buf_type type = 0;
2954 
2955 	dprintk("open dev=%s\n", video_device_node_name(vdev));
2956 
2957 	if (vdev->vfl_type == VFL_TYPE_VIDEO) {
2958 		type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2959 	} else if (vdev->vfl_type == VFL_TYPE_VBI) {
2960 		type = V4L2_BUF_TYPE_VBI_CAPTURE;
2961 	} else {
2962 		WARN_ON(1);
2963 		return -ENODEV;
2964 	}
2965 
2966 	dprintk("%d: open called (type=%s)\n",
2967 		btv->c.nr, v4l2_type_names[type]);
2968 
2969 	/* allocate per filehandle data */
2970 	fh = kmalloc(sizeof(*fh), GFP_KERNEL);
2971 	if (unlikely(!fh))
2972 		return -ENOMEM;
2973 	btv->users++;
2974 	file->private_data = fh;
2975 
2976 	*fh = btv->init;
2977 	v4l2_fh_init(&fh->fh, vdev);
2978 
2979 	fh->type = type;
2980 	fh->ov.setup_ok = 0;
2981 
2982 	videobuf_queue_sg_init(&fh->cap, &bttv_video_qops,
2983 			    &btv->c.pci->dev, &btv->s_lock,
2984 			    V4L2_BUF_TYPE_VIDEO_CAPTURE,
2985 			    V4L2_FIELD_INTERLACED,
2986 			    sizeof(struct bttv_buffer),
2987 			    fh, &btv->lock);
2988 	videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops,
2989 			    &btv->c.pci->dev, &btv->s_lock,
2990 			    V4L2_BUF_TYPE_VBI_CAPTURE,
2991 			    V4L2_FIELD_SEQ_TB,
2992 			    sizeof(struct bttv_buffer),
2993 			    fh, &btv->lock);
2994 	set_tvnorm(btv,btv->tvnorm);
2995 	set_input(btv, btv->input, btv->tvnorm);
2996 	audio_mute(btv, btv->mute);
2997 
2998 	/* The V4L2 spec requires one global set of cropping parameters
2999 	   which only change on request. These are stored in btv->crop[1].
3000 	   However for compatibility with V4L apps and cropping unaware
3001 	   V4L2 apps we now reset the cropping parameters as seen through
3002 	   this fh, which is to say VIDIOC_G_SELECTION and scaling limit checks
3003 	   will use btv->crop[0], the default cropping parameters for the
3004 	   current video standard, and VIDIOC_S_FMT will not implicitly
3005 	   change the cropping parameters until VIDIOC_S_SELECTION has been
3006 	   called. */
3007 	fh->do_crop = !reset_crop; /* module parameter */
3008 
3009 	/* Likewise there should be one global set of VBI capture
3010 	   parameters, but for compatibility with V4L apps and earlier
3011 	   driver versions each fh has its own parameters. */
3012 	bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3013 
3014 	bttv_field_count(btv);
3015 	v4l2_fh_add(&fh->fh);
3016 	return 0;
3017 }
3018 
bttv_release(struct file * file)3019 static int bttv_release(struct file *file)
3020 {
3021 	struct bttv_fh *fh = file->private_data;
3022 	struct bttv *btv = fh->btv;
3023 
3024 	/* turn off overlay */
3025 	if (check_btres(fh, RESOURCE_OVERLAY))
3026 		bttv_switch_overlay(btv,fh,NULL);
3027 
3028 	/* stop video capture */
3029 	if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
3030 		videobuf_streamoff(&fh->cap);
3031 		free_btres_lock(btv,fh,RESOURCE_VIDEO_STREAM);
3032 	}
3033 	if (fh->cap.read_buf) {
3034 		buffer_release(&fh->cap,fh->cap.read_buf);
3035 		kfree(fh->cap.read_buf);
3036 	}
3037 	if (check_btres(fh, RESOURCE_VIDEO_READ)) {
3038 		free_btres_lock(btv, fh, RESOURCE_VIDEO_READ);
3039 	}
3040 
3041 	/* stop vbi capture */
3042 	if (check_btres(fh, RESOURCE_VBI)) {
3043 		videobuf_stop(&fh->vbi);
3044 		free_btres_lock(btv,fh,RESOURCE_VBI);
3045 	}
3046 
3047 	/* free stuff */
3048 
3049 	videobuf_mmap_free(&fh->cap);
3050 	videobuf_mmap_free(&fh->vbi);
3051 	file->private_data = NULL;
3052 
3053 	btv->users--;
3054 	bttv_field_count(btv);
3055 
3056 	if (!btv->users)
3057 		audio_mute(btv, btv->mute);
3058 
3059 	v4l2_fh_del(&fh->fh);
3060 	v4l2_fh_exit(&fh->fh);
3061 	kfree(fh);
3062 	return 0;
3063 }
3064 
3065 static int
bttv_mmap(struct file * file,struct vm_area_struct * vma)3066 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3067 {
3068 	struct bttv_fh *fh = file->private_data;
3069 
3070 	dprintk("%d: mmap type=%s 0x%lx+%ld\n",
3071 		fh->btv->c.nr, v4l2_type_names[fh->type],
3072 		vma->vm_start, vma->vm_end - vma->vm_start);
3073 	return videobuf_mmap_mapper(bttv_queue(fh),vma);
3074 }
3075 
3076 static const struct v4l2_file_operations bttv_fops =
3077 {
3078 	.owner		  = THIS_MODULE,
3079 	.open		  = bttv_open,
3080 	.release	  = bttv_release,
3081 	.unlocked_ioctl	  = video_ioctl2,
3082 	.read		  = bttv_read,
3083 	.mmap		  = bttv_mmap,
3084 	.poll		  = bttv_poll,
3085 };
3086 
3087 static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
3088 	.vidioc_querycap                = bttv_querycap,
3089 	.vidioc_enum_fmt_vid_cap        = bttv_enum_fmt_vid_cap,
3090 	.vidioc_g_fmt_vid_cap           = bttv_g_fmt_vid_cap,
3091 	.vidioc_try_fmt_vid_cap         = bttv_try_fmt_vid_cap,
3092 	.vidioc_s_fmt_vid_cap           = bttv_s_fmt_vid_cap,
3093 	.vidioc_enum_fmt_vid_overlay    = bttv_enum_fmt_vid_overlay,
3094 	.vidioc_g_fmt_vid_overlay       = bttv_g_fmt_vid_overlay,
3095 	.vidioc_try_fmt_vid_overlay     = bttv_try_fmt_vid_overlay,
3096 	.vidioc_s_fmt_vid_overlay       = bttv_s_fmt_vid_overlay,
3097 	.vidioc_g_fmt_vbi_cap           = bttv_g_fmt_vbi_cap,
3098 	.vidioc_try_fmt_vbi_cap         = bttv_try_fmt_vbi_cap,
3099 	.vidioc_s_fmt_vbi_cap           = bttv_s_fmt_vbi_cap,
3100 	.vidioc_g_pixelaspect           = bttv_g_pixelaspect,
3101 	.vidioc_reqbufs                 = bttv_reqbufs,
3102 	.vidioc_querybuf                = bttv_querybuf,
3103 	.vidioc_qbuf                    = bttv_qbuf,
3104 	.vidioc_dqbuf                   = bttv_dqbuf,
3105 	.vidioc_s_std                   = bttv_s_std,
3106 	.vidioc_g_std                   = bttv_g_std,
3107 	.vidioc_enum_input              = bttv_enum_input,
3108 	.vidioc_g_input                 = bttv_g_input,
3109 	.vidioc_s_input                 = bttv_s_input,
3110 	.vidioc_streamon                = bttv_streamon,
3111 	.vidioc_streamoff               = bttv_streamoff,
3112 	.vidioc_g_tuner                 = bttv_g_tuner,
3113 	.vidioc_s_tuner                 = bttv_s_tuner,
3114 	.vidioc_g_selection             = bttv_g_selection,
3115 	.vidioc_s_selection             = bttv_s_selection,
3116 	.vidioc_g_fbuf                  = bttv_g_fbuf,
3117 	.vidioc_s_fbuf                  = bttv_s_fbuf,
3118 	.vidioc_overlay                 = bttv_overlay,
3119 	.vidioc_g_parm                  = bttv_g_parm,
3120 	.vidioc_g_frequency             = bttv_g_frequency,
3121 	.vidioc_s_frequency             = bttv_s_frequency,
3122 	.vidioc_log_status		= bttv_log_status,
3123 	.vidioc_querystd		= bttv_querystd,
3124 	.vidioc_subscribe_event		= v4l2_ctrl_subscribe_event,
3125 	.vidioc_unsubscribe_event	= v4l2_event_unsubscribe,
3126 #ifdef CONFIG_VIDEO_ADV_DEBUG
3127 	.vidioc_g_register		= bttv_g_register,
3128 	.vidioc_s_register		= bttv_s_register,
3129 #endif
3130 };
3131 
3132 static struct video_device bttv_video_template = {
3133 	.fops         = &bttv_fops,
3134 	.ioctl_ops    = &bttv_ioctl_ops,
3135 	.tvnorms      = BTTV_NORMS,
3136 };
3137 
3138 /* ----------------------------------------------------------------------- */
3139 /* radio interface                                                         */
3140 
radio_open(struct file * file)3141 static int radio_open(struct file *file)
3142 {
3143 	struct video_device *vdev = video_devdata(file);
3144 	struct bttv *btv = video_drvdata(file);
3145 	struct bttv_fh *fh;
3146 
3147 	dprintk("open dev=%s\n", video_device_node_name(vdev));
3148 
3149 	dprintk("%d: open called (radio)\n", btv->c.nr);
3150 
3151 	/* allocate per filehandle data */
3152 	fh = kmalloc(sizeof(*fh), GFP_KERNEL);
3153 	if (unlikely(!fh))
3154 		return -ENOMEM;
3155 	file->private_data = fh;
3156 	*fh = btv->init;
3157 	v4l2_fh_init(&fh->fh, vdev);
3158 
3159 	btv->radio_user++;
3160 	audio_mute(btv, btv->mute);
3161 
3162 	v4l2_fh_add(&fh->fh);
3163 
3164 	return 0;
3165 }
3166 
radio_release(struct file * file)3167 static int radio_release(struct file *file)
3168 {
3169 	struct bttv_fh *fh = file->private_data;
3170 	struct bttv *btv = fh->btv;
3171 	struct saa6588_command cmd;
3172 
3173 	file->private_data = NULL;
3174 	v4l2_fh_del(&fh->fh);
3175 	v4l2_fh_exit(&fh->fh);
3176 	kfree(fh);
3177 
3178 	btv->radio_user--;
3179 
3180 	bttv_call_all(btv, core, command, SAA6588_CMD_CLOSE, &cmd);
3181 
3182 	if (btv->radio_user == 0)
3183 		btv->has_radio_tuner = 0;
3184 	return 0;
3185 }
3186 
radio_g_tuner(struct file * file,void * priv,struct v4l2_tuner * t)3187 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3188 {
3189 	struct bttv_fh *fh = priv;
3190 	struct bttv *btv = fh->btv;
3191 
3192 	if (0 != t->index)
3193 		return -EINVAL;
3194 	strscpy(t->name, "Radio", sizeof(t->name));
3195 	t->type = V4L2_TUNER_RADIO;
3196 	radio_enable(btv);
3197 
3198 	bttv_call_all(btv, tuner, g_tuner, t);
3199 
3200 	if (btv->audio_mode_gpio)
3201 		btv->audio_mode_gpio(btv, t, 0);
3202 
3203 	if (btv->has_tea575x)
3204 		return snd_tea575x_g_tuner(&btv->tea, t);
3205 
3206 	return 0;
3207 }
3208 
radio_s_tuner(struct file * file,void * priv,const struct v4l2_tuner * t)3209 static int radio_s_tuner(struct file *file, void *priv,
3210 					const struct v4l2_tuner *t)
3211 {
3212 	struct bttv_fh *fh = priv;
3213 	struct bttv *btv = fh->btv;
3214 
3215 	if (0 != t->index)
3216 		return -EINVAL;
3217 
3218 	radio_enable(btv);
3219 	bttv_call_all(btv, tuner, s_tuner, t);
3220 	return 0;
3221 }
3222 
radio_s_hw_freq_seek(struct file * file,void * priv,const struct v4l2_hw_freq_seek * a)3223 static int radio_s_hw_freq_seek(struct file *file, void *priv,
3224 					const struct v4l2_hw_freq_seek *a)
3225 {
3226 	struct bttv_fh *fh = priv;
3227 	struct bttv *btv = fh->btv;
3228 
3229 	if (btv->has_tea575x)
3230 		return snd_tea575x_s_hw_freq_seek(file, &btv->tea, a);
3231 
3232 	return -ENOTTY;
3233 }
3234 
radio_enum_freq_bands(struct file * file,void * priv,struct v4l2_frequency_band * band)3235 static int radio_enum_freq_bands(struct file *file, void *priv,
3236 					 struct v4l2_frequency_band *band)
3237 {
3238 	struct bttv_fh *fh = priv;
3239 	struct bttv *btv = fh->btv;
3240 
3241 	if (btv->has_tea575x)
3242 		return snd_tea575x_enum_freq_bands(&btv->tea, band);
3243 
3244 	return -ENOTTY;
3245 }
3246 
radio_read(struct file * file,char __user * data,size_t count,loff_t * ppos)3247 static ssize_t radio_read(struct file *file, char __user *data,
3248 			 size_t count, loff_t *ppos)
3249 {
3250 	struct bttv_fh *fh = file->private_data;
3251 	struct bttv *btv = fh->btv;
3252 	struct saa6588_command cmd;
3253 
3254 	cmd.block_count = count / 3;
3255 	cmd.nonblocking = file->f_flags & O_NONBLOCK;
3256 	cmd.buffer = data;
3257 	cmd.instance = file;
3258 	cmd.result = -ENODEV;
3259 	radio_enable(btv);
3260 
3261 	bttv_call_all(btv, core, command, SAA6588_CMD_READ, &cmd);
3262 
3263 	return cmd.result;
3264 }
3265 
radio_poll(struct file * file,poll_table * wait)3266 static __poll_t radio_poll(struct file *file, poll_table *wait)
3267 {
3268 	struct bttv_fh *fh = file->private_data;
3269 	struct bttv *btv = fh->btv;
3270 	__poll_t req_events = poll_requested_events(wait);
3271 	struct saa6588_command cmd;
3272 	__poll_t res = 0;
3273 
3274 	if (v4l2_event_pending(&fh->fh))
3275 		res = EPOLLPRI;
3276 	else if (req_events & EPOLLPRI)
3277 		poll_wait(file, &fh->fh.wait, wait);
3278 	radio_enable(btv);
3279 	cmd.instance = file;
3280 	cmd.event_list = wait;
3281 	cmd.poll_mask = res;
3282 	bttv_call_all(btv, core, command, SAA6588_CMD_POLL, &cmd);
3283 
3284 	return cmd.poll_mask;
3285 }
3286 
3287 static const struct v4l2_file_operations radio_fops =
3288 {
3289 	.owner	  = THIS_MODULE,
3290 	.open	  = radio_open,
3291 	.read     = radio_read,
3292 	.release  = radio_release,
3293 	.unlocked_ioctl = video_ioctl2,
3294 	.poll     = radio_poll,
3295 };
3296 
3297 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
3298 	.vidioc_querycap        = bttv_querycap,
3299 	.vidioc_log_status	= bttv_log_status,
3300 	.vidioc_g_tuner         = radio_g_tuner,
3301 	.vidioc_s_tuner         = radio_s_tuner,
3302 	.vidioc_g_frequency     = bttv_g_frequency,
3303 	.vidioc_s_frequency     = bttv_s_frequency,
3304 	.vidioc_s_hw_freq_seek	= radio_s_hw_freq_seek,
3305 	.vidioc_enum_freq_bands	= radio_enum_freq_bands,
3306 	.vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
3307 	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
3308 };
3309 
3310 static struct video_device radio_template = {
3311 	.fops      = &radio_fops,
3312 	.ioctl_ops = &radio_ioctl_ops,
3313 };
3314 
3315 /* ----------------------------------------------------------------------- */
3316 /* some debug code                                                         */
3317 
bttv_risc_decode(u32 risc)3318 static int bttv_risc_decode(u32 risc)
3319 {
3320 	static char *instr[16] = {
3321 		[ BT848_RISC_WRITE     >> 28 ] = "write",
3322 		[ BT848_RISC_SKIP      >> 28 ] = "skip",
3323 		[ BT848_RISC_WRITEC    >> 28 ] = "writec",
3324 		[ BT848_RISC_JUMP      >> 28 ] = "jump",
3325 		[ BT848_RISC_SYNC      >> 28 ] = "sync",
3326 		[ BT848_RISC_WRITE123  >> 28 ] = "write123",
3327 		[ BT848_RISC_SKIP123   >> 28 ] = "skip123",
3328 		[ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3329 	};
3330 	static int incr[16] = {
3331 		[ BT848_RISC_WRITE     >> 28 ] = 2,
3332 		[ BT848_RISC_JUMP      >> 28 ] = 2,
3333 		[ BT848_RISC_SYNC      >> 28 ] = 2,
3334 		[ BT848_RISC_WRITE123  >> 28 ] = 5,
3335 		[ BT848_RISC_SKIP123   >> 28 ] = 2,
3336 		[ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3337 	};
3338 	static char *bits[] = {
3339 		"be0",  "be1",  "be2",  "be3/resync",
3340 		"set0", "set1", "set2", "set3",
3341 		"clr0", "clr1", "clr2", "clr3",
3342 		"irq",  "res",  "eol",  "sol",
3343 	};
3344 	int i;
3345 
3346 	pr_cont("0x%08x [ %s", risc,
3347 	       instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3348 	for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3349 		if (risc & (1 << (i + 12)))
3350 			pr_cont(" %s", bits[i]);
3351 	pr_cont(" count=%d ]\n", risc & 0xfff);
3352 	return incr[risc >> 28] ? incr[risc >> 28] : 1;
3353 }
3354 
bttv_risc_disasm(struct bttv * btv,struct btcx_riscmem * risc)3355 static void bttv_risc_disasm(struct bttv *btv,
3356 			     struct btcx_riscmem *risc)
3357 {
3358 	unsigned int i,j,n;
3359 
3360 	pr_info("%s: risc disasm: %p [dma=0x%08lx]\n",
3361 		btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma);
3362 	for (i = 0; i < (risc->size >> 2); i += n) {
3363 		pr_info("%s:   0x%lx: ",
3364 			btv->c.v4l2_dev.name,
3365 			(unsigned long)(risc->dma + (i<<2)));
3366 		n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
3367 		for (j = 1; j < n; j++)
3368 			pr_info("%s:   0x%lx: 0x%08x [ arg #%d ]\n",
3369 				btv->c.v4l2_dev.name,
3370 				(unsigned long)(risc->dma + ((i+j)<<2)),
3371 				risc->cpu[i+j], j);
3372 		if (0 == risc->cpu[i])
3373 			break;
3374 	}
3375 }
3376 
bttv_print_riscaddr(struct bttv * btv)3377 static void bttv_print_riscaddr(struct bttv *btv)
3378 {
3379 	pr_info("  main: %08llx\n", (unsigned long long)btv->main.dma);
3380 	pr_info("  vbi : o=%08llx e=%08llx\n",
3381 		btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3382 		btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3383 	pr_info("  cap : o=%08llx e=%08llx\n",
3384 		btv->curr.top
3385 		? (unsigned long long)btv->curr.top->top.dma : 0,
3386 		btv->curr.bottom
3387 		? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3388 	pr_info("  scr : o=%08llx e=%08llx\n",
3389 		btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3390 		btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3391 	bttv_risc_disasm(btv, &btv->main);
3392 }
3393 
3394 /* ----------------------------------------------------------------------- */
3395 /* irq handler                                                             */
3396 
3397 static char *irq_name[] = {
3398 	"FMTCHG",  // format change detected (525 vs. 625)
3399 	"VSYNC",   // vertical sync (new field)
3400 	"HSYNC",   // horizontal sync
3401 	"OFLOW",   // chroma/luma AGC overflow
3402 	"HLOCK",   // horizontal lock changed
3403 	"VPRES",   // video presence changed
3404 	"6", "7",
3405 	"I2CDONE", // hw irc operation finished
3406 	"GPINT",   // gpio port triggered irq
3407 	"10",
3408 	"RISCI",   // risc instruction triggered irq
3409 	"FBUS",    // pixel data fifo dropped data (high pci bus latencies)
3410 	"FTRGT",   // pixel data fifo overrun
3411 	"FDSR",    // fifo data stream resyncronisation
3412 	"PPERR",   // parity error (data transfer)
3413 	"RIPERR",  // parity error (read risc instructions)
3414 	"PABORT",  // pci abort
3415 	"OCERR",   // risc instruction error
3416 	"SCERR",   // syncronisation error
3417 };
3418 
bttv_print_irqbits(u32 print,u32 mark)3419 static void bttv_print_irqbits(u32 print, u32 mark)
3420 {
3421 	unsigned int i;
3422 
3423 	pr_cont("bits:");
3424 	for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3425 		if (print & (1 << i))
3426 			pr_cont(" %s", irq_name[i]);
3427 		if (mark & (1 << i))
3428 			pr_cont("*");
3429 	}
3430 }
3431 
bttv_irq_debug_low_latency(struct bttv * btv,u32 rc)3432 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3433 {
3434 	pr_warn("%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3435 		btv->c.nr,
3436 		(unsigned long)btv->main.dma,
3437 		(unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
3438 		(unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
3439 		(unsigned long)rc);
3440 
3441 	if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3442 		pr_notice("%d: Oh, there (temporarily?) is no input signal. Ok, then this is harmless, don't worry ;)\n",
3443 			  btv->c.nr);
3444 		return;
3445 	}
3446 	pr_notice("%d: Uhm. Looks like we have unusual high IRQ latencies\n",
3447 		  btv->c.nr);
3448 	pr_notice("%d: Lets try to catch the culprit red-handed ...\n",
3449 		  btv->c.nr);
3450 	dump_stack();
3451 }
3452 
3453 static int
bttv_irq_next_video(struct bttv * btv,struct bttv_buffer_set * set)3454 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3455 {
3456 	struct bttv_buffer *item;
3457 
3458 	memset(set,0,sizeof(*set));
3459 
3460 	/* capture request ? */
3461 	if (!list_empty(&btv->capture)) {
3462 		set->frame_irq = 1;
3463 		item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3464 		if (V4L2_FIELD_HAS_TOP(item->vb.field))
3465 			set->top    = item;
3466 		if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3467 			set->bottom = item;
3468 
3469 		/* capture request for other field ? */
3470 		if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3471 		    (item->vb.queue.next != &btv->capture)) {
3472 			item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3473 			/* Mike Isely <isely@pobox.com> - Only check
3474 			 * and set up the bottom field in the logic
3475 			 * below.  Don't ever do the top field.  This
3476 			 * of course means that if we set up the
3477 			 * bottom field in the above code that we'll
3478 			 * actually skip a field.  But that's OK.
3479 			 * Having processed only a single buffer this
3480 			 * time, then the next time around the first
3481 			 * available buffer should be for a top field.
3482 			 * That will then cause us here to set up a
3483 			 * top then a bottom field in the normal way.
3484 			 * The alternative to this understanding is
3485 			 * that we set up the second available buffer
3486 			 * as a top field, but that's out of order
3487 			 * since this driver always processes the top
3488 			 * field first - the effect will be the two
3489 			 * buffers being returned in the wrong order,
3490 			 * with the second buffer also being delayed
3491 			 * by one field time (owing to the fifo nature
3492 			 * of videobuf).  Worse still, we'll be stuck
3493 			 * doing fields out of order now every time
3494 			 * until something else causes a field to be
3495 			 * dropped.  By effectively forcing a field to
3496 			 * drop this way then we always get back into
3497 			 * sync within a single frame time.  (Out of
3498 			 * order fields can screw up deinterlacing
3499 			 * algorithms.) */
3500 			if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3501 				if (NULL == set->bottom &&
3502 				    V4L2_FIELD_BOTTOM == item->vb.field) {
3503 					set->bottom = item;
3504 				}
3505 				if (NULL != set->top  &&  NULL != set->bottom)
3506 					set->top_irq = 2;
3507 			}
3508 		}
3509 	}
3510 
3511 	/* screen overlay ? */
3512 	if (NULL != btv->screen) {
3513 		if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3514 			if (NULL == set->top && NULL == set->bottom) {
3515 				set->top    = btv->screen;
3516 				set->bottom = btv->screen;
3517 			}
3518 		} else {
3519 			if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3520 			    NULL == set->top) {
3521 				set->top = btv->screen;
3522 			}
3523 			if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3524 			    NULL == set->bottom) {
3525 				set->bottom = btv->screen;
3526 			}
3527 		}
3528 	}
3529 
3530 	dprintk("%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3531 		btv->c.nr, set->top, set->bottom,
3532 		btv->screen, set->frame_irq, set->top_irq);
3533 	return 0;
3534 }
3535 
3536 static void
bttv_irq_wakeup_video(struct bttv * btv,struct bttv_buffer_set * wakeup,struct bttv_buffer_set * curr,unsigned int state)3537 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3538 		      struct bttv_buffer_set *curr, unsigned int state)
3539 {
3540 	u64 ts = ktime_get_ns();
3541 
3542 	if (wakeup->top == wakeup->bottom) {
3543 		if (NULL != wakeup->top && curr->top != wakeup->top) {
3544 			if (irq_debug > 1)
3545 				pr_debug("%d: wakeup: both=%p\n",
3546 					 btv->c.nr, wakeup->top);
3547 			wakeup->top->vb.ts = ts;
3548 			wakeup->top->vb.field_count = btv->field_count;
3549 			wakeup->top->vb.state = state;
3550 			wake_up(&wakeup->top->vb.done);
3551 		}
3552 	} else {
3553 		if (NULL != wakeup->top && curr->top != wakeup->top) {
3554 			if (irq_debug > 1)
3555 				pr_debug("%d: wakeup: top=%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 		if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3563 			if (irq_debug > 1)
3564 				pr_debug("%d: wakeup: bottom=%p\n",
3565 					 btv->c.nr, wakeup->bottom);
3566 			wakeup->bottom->vb.ts = ts;
3567 			wakeup->bottom->vb.field_count = btv->field_count;
3568 			wakeup->bottom->vb.state = state;
3569 			wake_up(&wakeup->bottom->vb.done);
3570 		}
3571 	}
3572 }
3573 
3574 static void
bttv_irq_wakeup_vbi(struct bttv * btv,struct bttv_buffer * wakeup,unsigned int state)3575 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3576 		    unsigned int state)
3577 {
3578 	if (NULL == wakeup)
3579 		return;
3580 
3581 	wakeup->vb.ts = ktime_get_ns();
3582 	wakeup->vb.field_count = btv->field_count;
3583 	wakeup->vb.state = state;
3584 	wake_up(&wakeup->vb.done);
3585 }
3586 
bttv_irq_timeout(struct timer_list * t)3587 static void bttv_irq_timeout(struct timer_list *t)
3588 {
3589 	struct bttv *btv = from_timer(btv, t, timeout);
3590 	struct bttv_buffer_set old,new;
3591 	struct bttv_buffer *ovbi;
3592 	struct bttv_buffer *item;
3593 	unsigned long flags;
3594 
3595 	if (bttv_verbose) {
3596 		pr_info("%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3597 			btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3598 			btread(BT848_RISC_COUNT));
3599 		bttv_print_irqbits(btread(BT848_INT_STAT),0);
3600 		pr_cont("\n");
3601 	}
3602 
3603 	spin_lock_irqsave(&btv->s_lock,flags);
3604 
3605 	/* deactivate stuff */
3606 	memset(&new,0,sizeof(new));
3607 	old  = btv->curr;
3608 	ovbi = btv->cvbi;
3609 	btv->curr = new;
3610 	btv->cvbi = NULL;
3611 	btv->loop_irq = 0;
3612 	bttv_buffer_activate_video(btv, &new);
3613 	bttv_buffer_activate_vbi(btv,   NULL);
3614 	bttv_set_dma(btv, 0);
3615 
3616 	/* wake up */
3617 	bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
3618 	bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
3619 
3620 	/* cancel all outstanding capture / vbi requests */
3621 	while (!list_empty(&btv->capture)) {
3622 		item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3623 		list_del(&item->vb.queue);
3624 		item->vb.state = VIDEOBUF_ERROR;
3625 		wake_up(&item->vb.done);
3626 	}
3627 	while (!list_empty(&btv->vcapture)) {
3628 		item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3629 		list_del(&item->vb.queue);
3630 		item->vb.state = VIDEOBUF_ERROR;
3631 		wake_up(&item->vb.done);
3632 	}
3633 
3634 	btv->errors++;
3635 	spin_unlock_irqrestore(&btv->s_lock,flags);
3636 }
3637 
3638 static void
bttv_irq_wakeup_top(struct bttv * btv)3639 bttv_irq_wakeup_top(struct bttv *btv)
3640 {
3641 	struct bttv_buffer *wakeup = btv->curr.top;
3642 
3643 	if (NULL == wakeup)
3644 		return;
3645 
3646 	spin_lock(&btv->s_lock);
3647 	btv->curr.top_irq = 0;
3648 	btv->curr.top = NULL;
3649 	bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3650 
3651 	wakeup->vb.ts = ktime_get_ns();
3652 	wakeup->vb.field_count = btv->field_count;
3653 	wakeup->vb.state = VIDEOBUF_DONE;
3654 	wake_up(&wakeup->vb.done);
3655 	spin_unlock(&btv->s_lock);
3656 }
3657 
is_active(struct btcx_riscmem * risc,u32 rc)3658 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
3659 {
3660 	if (rc < risc->dma)
3661 		return 0;
3662 	if (rc > risc->dma + risc->size)
3663 		return 0;
3664 	return 1;
3665 }
3666 
3667 static void
bttv_irq_switch_video(struct bttv * btv)3668 bttv_irq_switch_video(struct bttv *btv)
3669 {
3670 	struct bttv_buffer_set new;
3671 	struct bttv_buffer_set old;
3672 	dma_addr_t rc;
3673 
3674 	spin_lock(&btv->s_lock);
3675 
3676 	/* new buffer set */
3677 	bttv_irq_next_video(btv, &new);
3678 	rc = btread(BT848_RISC_COUNT);
3679 	if ((btv->curr.top    && is_active(&btv->curr.top->top,       rc)) ||
3680 	    (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
3681 		btv->framedrop++;
3682 		if (debug_latency)
3683 			bttv_irq_debug_low_latency(btv, rc);
3684 		spin_unlock(&btv->s_lock);
3685 		return;
3686 	}
3687 
3688 	/* switch over */
3689 	old = btv->curr;
3690 	btv->curr = new;
3691 	btv->loop_irq &= ~1;
3692 	bttv_buffer_activate_video(btv, &new);
3693 	bttv_set_dma(btv, 0);
3694 
3695 	/* switch input */
3696 	if (UNSET != btv->new_input) {
3697 		video_mux(btv,btv->new_input);
3698 		btv->new_input = UNSET;
3699 	}
3700 
3701 	/* wake up finished buffers */
3702 	bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
3703 	spin_unlock(&btv->s_lock);
3704 }
3705 
3706 static void
bttv_irq_switch_vbi(struct bttv * btv)3707 bttv_irq_switch_vbi(struct bttv *btv)
3708 {
3709 	struct bttv_buffer *new = NULL;
3710 	struct bttv_buffer *old;
3711 	u32 rc;
3712 
3713 	spin_lock(&btv->s_lock);
3714 
3715 	if (!list_empty(&btv->vcapture))
3716 		new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3717 	old = btv->cvbi;
3718 
3719 	rc = btread(BT848_RISC_COUNT);
3720 	if (NULL != old && (is_active(&old->top,    rc) ||
3721 			    is_active(&old->bottom, rc))) {
3722 		btv->framedrop++;
3723 		if (debug_latency)
3724 			bttv_irq_debug_low_latency(btv, rc);
3725 		spin_unlock(&btv->s_lock);
3726 		return;
3727 	}
3728 
3729 	/* switch */
3730 	btv->cvbi = new;
3731 	btv->loop_irq &= ~4;
3732 	bttv_buffer_activate_vbi(btv, new);
3733 	bttv_set_dma(btv, 0);
3734 
3735 	bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
3736 	spin_unlock(&btv->s_lock);
3737 }
3738 
bttv_irq(int irq,void * dev_id)3739 static irqreturn_t bttv_irq(int irq, void *dev_id)
3740 {
3741 	u32 stat,astat;
3742 	u32 dstat;
3743 	int count;
3744 	struct bttv *btv;
3745 	int handled = 0;
3746 
3747 	btv=(struct bttv *)dev_id;
3748 
3749 	count=0;
3750 	while (1) {
3751 		/* get/clear interrupt status bits */
3752 		stat=btread(BT848_INT_STAT);
3753 		astat=stat&btread(BT848_INT_MASK);
3754 		if (!astat)
3755 			break;
3756 		handled = 1;
3757 		btwrite(stat,BT848_INT_STAT);
3758 
3759 		/* get device status bits */
3760 		dstat=btread(BT848_DSTATUS);
3761 
3762 		if (irq_debug) {
3763 			pr_debug("%d: irq loop=%d fc=%d riscs=%x, riscc=%08x, ",
3764 				 btv->c.nr, count, btv->field_count,
3765 				 stat>>28, btread(BT848_RISC_COUNT));
3766 			bttv_print_irqbits(stat,astat);
3767 			if (stat & BT848_INT_HLOCK)
3768 				pr_cont("   HLOC => %s",
3769 					dstat & BT848_DSTATUS_HLOC
3770 					? "yes" : "no");
3771 			if (stat & BT848_INT_VPRES)
3772 				pr_cont("   PRES => %s",
3773 					dstat & BT848_DSTATUS_PRES
3774 					? "yes" : "no");
3775 			if (stat & BT848_INT_FMTCHG)
3776 				pr_cont("   NUML => %s",
3777 					dstat & BT848_DSTATUS_NUML
3778 					? "625" : "525");
3779 			pr_cont("\n");
3780 		}
3781 
3782 		if (astat&BT848_INT_VSYNC)
3783 			btv->field_count++;
3784 
3785 		if ((astat & BT848_INT_GPINT) && btv->remote) {
3786 			bttv_input_irq(btv);
3787 		}
3788 
3789 		if (astat & BT848_INT_I2CDONE) {
3790 			btv->i2c_done = stat;
3791 			wake_up(&btv->i2c_queue);
3792 		}
3793 
3794 		if ((astat & BT848_INT_RISCI)  &&  (stat & (4<<28)))
3795 			bttv_irq_switch_vbi(btv);
3796 
3797 		if ((astat & BT848_INT_RISCI)  &&  (stat & (2<<28)))
3798 			bttv_irq_wakeup_top(btv);
3799 
3800 		if ((astat & BT848_INT_RISCI)  &&  (stat & (1<<28)))
3801 			bttv_irq_switch_video(btv);
3802 
3803 		if ((astat & BT848_INT_HLOCK)  &&  btv->opt_automute)
3804 			/* trigger automute */
3805 			audio_mux_gpio(btv, btv->audio_input, btv->mute);
3806 
3807 		if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
3808 			pr_info("%d: %s%s @ %08x,",
3809 				btv->c.nr,
3810 				(astat & BT848_INT_SCERR) ? "SCERR" : "",
3811 				(astat & BT848_INT_OCERR) ? "OCERR" : "",
3812 				btread(BT848_RISC_COUNT));
3813 			bttv_print_irqbits(stat,astat);
3814 			pr_cont("\n");
3815 			if (bttv_debug)
3816 				bttv_print_riscaddr(btv);
3817 		}
3818 		if (fdsr && astat & BT848_INT_FDSR) {
3819 			pr_info("%d: FDSR @ %08x\n",
3820 				btv->c.nr, btread(BT848_RISC_COUNT));
3821 			if (bttv_debug)
3822 				bttv_print_riscaddr(btv);
3823 		}
3824 
3825 		count++;
3826 		if (count > 4) {
3827 
3828 			if (count > 8 || !(astat & BT848_INT_GPINT)) {
3829 				btwrite(0, BT848_INT_MASK);
3830 
3831 				pr_err("%d: IRQ lockup, cleared int mask [",
3832 				       btv->c.nr);
3833 			} else {
3834 				pr_err("%d: IRQ lockup, clearing GPINT from int mask [",
3835 				       btv->c.nr);
3836 
3837 				btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
3838 						BT848_INT_MASK);
3839 			}
3840 
3841 			bttv_print_irqbits(stat,astat);
3842 
3843 			pr_cont("]\n");
3844 		}
3845 	}
3846 	btv->irq_total++;
3847 	if (handled)
3848 		btv->irq_me++;
3849 	return IRQ_RETVAL(handled);
3850 }
3851 
3852 
3853 /* ----------------------------------------------------------------------- */
3854 /* initialization                                                          */
3855 
vdev_init(struct bttv * btv,struct video_device * vfd,const struct video_device * template,const char * type_name)3856 static void vdev_init(struct bttv *btv,
3857 		      struct video_device *vfd,
3858 		      const struct video_device *template,
3859 		      const char *type_name)
3860 {
3861 	*vfd = *template;
3862 	vfd->v4l2_dev = &btv->c.v4l2_dev;
3863 	vfd->release = video_device_release_empty;
3864 	video_set_drvdata(vfd, btv);
3865 	snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
3866 		 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
3867 		 type_name, bttv_tvcards[btv->c.type].name);
3868 	if (btv->tuner_type == TUNER_ABSENT) {
3869 		v4l2_disable_ioctl(vfd, VIDIOC_G_FREQUENCY);
3870 		v4l2_disable_ioctl(vfd, VIDIOC_S_FREQUENCY);
3871 		v4l2_disable_ioctl(vfd, VIDIOC_G_TUNER);
3872 		v4l2_disable_ioctl(vfd, VIDIOC_S_TUNER);
3873 	}
3874 }
3875 
bttv_unregister_video(struct bttv * btv)3876 static void bttv_unregister_video(struct bttv *btv)
3877 {
3878 	video_unregister_device(&btv->video_dev);
3879 	video_unregister_device(&btv->vbi_dev);
3880 	video_unregister_device(&btv->radio_dev);
3881 }
3882 
3883 /* register video4linux devices */
bttv_register_video(struct bttv * btv)3884 static int bttv_register_video(struct bttv *btv)
3885 {
3886 	if (no_overlay > 0)
3887 		pr_notice("Overlay support disabled\n");
3888 
3889 	/* video */
3890 	vdev_init(btv, &btv->video_dev, &bttv_video_template, "video");
3891 	btv->video_dev.device_caps = V4L2_CAP_VIDEO_CAPTURE |
3892 				     V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
3893 	if (btv->tuner_type != TUNER_ABSENT)
3894 		btv->video_dev.device_caps |= V4L2_CAP_TUNER;
3895 	if (no_overlay <= 0)
3896 		btv->video_dev.device_caps |= V4L2_CAP_VIDEO_OVERLAY;
3897 
3898 	if (video_register_device(&btv->video_dev, VFL_TYPE_VIDEO,
3899 				  video_nr[btv->c.nr]) < 0)
3900 		goto err;
3901 	pr_info("%d: registered device %s\n",
3902 		btv->c.nr, video_device_node_name(&btv->video_dev));
3903 	if (device_create_file(&btv->video_dev.dev,
3904 				     &dev_attr_card)<0) {
3905 		pr_err("%d: device_create_file 'card' failed\n", btv->c.nr);
3906 		goto err;
3907 	}
3908 
3909 	/* vbi */
3910 	vdev_init(btv, &btv->vbi_dev, &bttv_video_template, "vbi");
3911 	btv->vbi_dev.device_caps = V4L2_CAP_VBI_CAPTURE | V4L2_CAP_READWRITE |
3912 				   V4L2_CAP_STREAMING;
3913 	if (btv->tuner_type != TUNER_ABSENT)
3914 		btv->vbi_dev.device_caps |= V4L2_CAP_TUNER;
3915 
3916 	if (video_register_device(&btv->vbi_dev, VFL_TYPE_VBI,
3917 				  vbi_nr[btv->c.nr]) < 0)
3918 		goto err;
3919 	pr_info("%d: registered device %s\n",
3920 		btv->c.nr, video_device_node_name(&btv->vbi_dev));
3921 
3922 	if (!btv->has_radio)
3923 		return 0;
3924 	/* radio */
3925 	vdev_init(btv, &btv->radio_dev, &radio_template, "radio");
3926 	btv->radio_dev.device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER;
3927 	if (btv->has_saa6588)
3928 		btv->radio_dev.device_caps |= V4L2_CAP_READWRITE |
3929 					      V4L2_CAP_RDS_CAPTURE;
3930 	if (btv->has_tea575x)
3931 		btv->radio_dev.device_caps |= V4L2_CAP_HW_FREQ_SEEK;
3932 	btv->radio_dev.ctrl_handler = &btv->radio_ctrl_handler;
3933 	if (video_register_device(&btv->radio_dev, VFL_TYPE_RADIO,
3934 				  radio_nr[btv->c.nr]) < 0)
3935 		goto err;
3936 	pr_info("%d: registered device %s\n",
3937 		btv->c.nr, video_device_node_name(&btv->radio_dev));
3938 
3939 	/* all done */
3940 	return 0;
3941 
3942  err:
3943 	bttv_unregister_video(btv);
3944 	return -1;
3945 }
3946 
3947 
3948 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
3949 /* response on cards with no firmware is not enabled by OF */
pci_set_command(struct pci_dev * dev)3950 static void pci_set_command(struct pci_dev *dev)
3951 {
3952 #if defined(__powerpc__)
3953 	unsigned int cmd;
3954 
3955 	pci_read_config_dword(dev, PCI_COMMAND, &cmd);
3956 	cmd = (cmd | PCI_COMMAND_MEMORY );
3957 	pci_write_config_dword(dev, PCI_COMMAND, cmd);
3958 #endif
3959 }
3960 
bttv_probe(struct pci_dev * dev,const struct pci_device_id * pci_id)3961 static int bttv_probe(struct pci_dev *dev, const struct pci_device_id *pci_id)
3962 {
3963 	struct v4l2_frequency init_freq = {
3964 		.tuner = 0,
3965 		.type = V4L2_TUNER_ANALOG_TV,
3966 		.frequency = 980,
3967 	};
3968 	int result;
3969 	unsigned char lat;
3970 	struct bttv *btv;
3971 	struct v4l2_ctrl_handler *hdl;
3972 
3973 	if (bttv_num == BTTV_MAX)
3974 		return -ENOMEM;
3975 	pr_info("Bt8xx card found (%d)\n", bttv_num);
3976 	bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL);
3977 	if (btv == NULL) {
3978 		pr_err("out of memory\n");
3979 		return -ENOMEM;
3980 	}
3981 	btv->c.nr  = bttv_num;
3982 	snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name),
3983 			"bttv%d", btv->c.nr);
3984 
3985 	/* initialize structs / fill in defaults */
3986 	mutex_init(&btv->lock);
3987 	spin_lock_init(&btv->s_lock);
3988 	spin_lock_init(&btv->gpio_lock);
3989 	init_waitqueue_head(&btv->i2c_queue);
3990 	INIT_LIST_HEAD(&btv->c.subs);
3991 	INIT_LIST_HEAD(&btv->capture);
3992 	INIT_LIST_HEAD(&btv->vcapture);
3993 
3994 	timer_setup(&btv->timeout, bttv_irq_timeout, 0);
3995 
3996 	btv->i2c_rc = -1;
3997 	btv->tuner_type  = UNSET;
3998 	btv->new_input   = UNSET;
3999 	btv->has_radio=radio[btv->c.nr];
4000 
4001 	/* pci stuff (init, get irq/mmio, ... */
4002 	btv->c.pci = dev;
4003 	btv->id  = dev->device;
4004 	if (pci_enable_device(dev)) {
4005 		pr_warn("%d: Can't enable device\n", btv->c.nr);
4006 		result = -EIO;
4007 		goto free_mem;
4008 	}
4009 	if (dma_set_mask(&dev->dev, DMA_BIT_MASK(32))) {
4010 		pr_warn("%d: No suitable DMA available\n", btv->c.nr);
4011 		result = -EIO;
4012 		goto free_mem;
4013 	}
4014 	if (!request_mem_region(pci_resource_start(dev,0),
4015 				pci_resource_len(dev,0),
4016 				btv->c.v4l2_dev.name)) {
4017 		pr_warn("%d: can't request iomem (0x%llx)\n",
4018 			btv->c.nr,
4019 			(unsigned long long)pci_resource_start(dev, 0));
4020 		result = -EBUSY;
4021 		goto free_mem;
4022 	}
4023 	pci_set_master(dev);
4024 	pci_set_command(dev);
4025 
4026 	result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev);
4027 	if (result < 0) {
4028 		pr_warn("%d: v4l2_device_register() failed\n", btv->c.nr);
4029 		goto fail0;
4030 	}
4031 	hdl = &btv->ctrl_handler;
4032 	v4l2_ctrl_handler_init(hdl, 20);
4033 	btv->c.v4l2_dev.ctrl_handler = hdl;
4034 	v4l2_ctrl_handler_init(&btv->radio_ctrl_handler, 6);
4035 
4036 	btv->revision = dev->revision;
4037 	pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4038 	pr_info("%d: Bt%d (rev %d) at %s, irq: %d, latency: %d, mmio: 0x%llx\n",
4039 		bttv_num, btv->id, btv->revision, pci_name(dev),
4040 		btv->c.pci->irq, lat,
4041 		(unsigned long long)pci_resource_start(dev, 0));
4042 	schedule();
4043 
4044 	btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4045 	if (NULL == btv->bt848_mmio) {
4046 		pr_err("%d: ioremap() failed\n", btv->c.nr);
4047 		result = -EIO;
4048 		goto fail1;
4049 	}
4050 
4051 	/* identify card */
4052 	bttv_idcard(btv);
4053 
4054 	/* disable irqs, register irq handler */
4055 	btwrite(0, BT848_INT_MASK);
4056 	result = request_irq(btv->c.pci->irq, bttv_irq,
4057 	    IRQF_SHARED, btv->c.v4l2_dev.name, (void *)btv);
4058 	if (result < 0) {
4059 		pr_err("%d: can't get IRQ %d\n",
4060 		       bttv_num, btv->c.pci->irq);
4061 		goto fail1;
4062 	}
4063 
4064 	if (0 != bttv_handle_chipset(btv)) {
4065 		result = -EIO;
4066 		goto fail2;
4067 	}
4068 
4069 	/* init options from insmod args */
4070 	btv->opt_combfilter = combfilter;
4071 	bttv_ctrl_combfilter.def = combfilter;
4072 	bttv_ctrl_lumafilter.def = lumafilter;
4073 	btv->opt_automute   = automute;
4074 	bttv_ctrl_automute.def = automute;
4075 	bttv_ctrl_agc_crush.def = agc_crush;
4076 	btv->opt_vcr_hack   = vcr_hack;
4077 	bttv_ctrl_vcr_hack.def = vcr_hack;
4078 	bttv_ctrl_whitecrush_upper.def = whitecrush_upper;
4079 	bttv_ctrl_whitecrush_lower.def = whitecrush_lower;
4080 	btv->opt_uv_ratio   = uv_ratio;
4081 	bttv_ctrl_uv_ratio.def = uv_ratio;
4082 	bttv_ctrl_full_luma.def = full_luma_range;
4083 	bttv_ctrl_coring.def = coring;
4084 
4085 	/* fill struct bttv with some useful defaults */
4086 	btv->init.btv         = btv;
4087 	btv->init.ov.w.width  = 320;
4088 	btv->init.ov.w.height = 240;
4089 	btv->init.fmt         = format_by_fourcc(V4L2_PIX_FMT_BGR24);
4090 	btv->init.width       = 320;
4091 	btv->init.height      = 240;
4092 	btv->init.ov.w.width  = 320;
4093 	btv->init.ov.w.height = 240;
4094 	btv->init.ov.field    = V4L2_FIELD_INTERLACED;
4095 	btv->input = 0;
4096 
4097 	v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4098 			V4L2_CID_BRIGHTNESS, 0, 0xff00, 0x100, 32768);
4099 	v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4100 			V4L2_CID_CONTRAST, 0, 0xff80, 0x80, 0x6c00);
4101 	v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4102 			V4L2_CID_SATURATION, 0, 0xff80, 0x80, 32768);
4103 	v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4104 			V4L2_CID_COLOR_KILLER, 0, 1, 1, 0);
4105 	v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4106 			V4L2_CID_HUE, 0, 0xff00, 0x100, 32768);
4107 	v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4108 			V4L2_CID_CHROMA_AGC, 0, 1, 1, !!chroma_agc);
4109 	v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4110 		V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
4111 	if (btv->volume_gpio)
4112 		v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4113 			V4L2_CID_AUDIO_VOLUME, 0, 0xff00, 0x100, 0xff00);
4114 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_combfilter, NULL);
4115 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_automute, NULL);
4116 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_lumafilter, NULL);
4117 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_agc_crush, NULL);
4118 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_vcr_hack, NULL);
4119 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_lower, NULL);
4120 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_upper, NULL);
4121 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_uv_ratio, NULL);
4122 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_full_luma, NULL);
4123 	v4l2_ctrl_new_custom(hdl, &bttv_ctrl_coring, NULL);
4124 
4125 	/* initialize hardware */
4126 	if (bttv_gpio)
4127 		bttv_gpio_tracking(btv,"pre-init");
4128 
4129 	bttv_risc_init_main(btv);
4130 	init_bt848(btv);
4131 
4132 	/* gpio */
4133 	btwrite(0x00, BT848_GPIO_REG_INP);
4134 	btwrite(0x00, BT848_GPIO_OUT_EN);
4135 	if (bttv_verbose)
4136 		bttv_gpio_tracking(btv,"init");
4137 
4138 	/* needs to be done before i2c is registered */
4139 	bttv_init_card1(btv);
4140 
4141 	/* register i2c + gpio */
4142 	init_bttv_i2c(btv);
4143 
4144 	/* some card-specific stuff (needs working i2c) */
4145 	bttv_init_card2(btv);
4146 	bttv_init_tuner(btv);
4147 	if (btv->tuner_type != TUNER_ABSENT) {
4148 		bttv_set_frequency(btv, &init_freq);
4149 		btv->radio_freq = 90500 * 16; /* 90.5Mhz default */
4150 	}
4151 	btv->std = V4L2_STD_PAL;
4152 	init_irqreg(btv);
4153 	if (!bttv_tvcards[btv->c.type].no_video)
4154 		v4l2_ctrl_handler_setup(hdl);
4155 	if (hdl->error) {
4156 		result = hdl->error;
4157 		goto fail2;
4158 	}
4159 	/* mute device */
4160 	audio_mute(btv, 1);
4161 
4162 	/* register video4linux + input */
4163 	if (!bttv_tvcards[btv->c.type].no_video) {
4164 		v4l2_ctrl_add_handler(&btv->radio_ctrl_handler, hdl,
4165 				v4l2_ctrl_radio_filter, false);
4166 		if (btv->radio_ctrl_handler.error) {
4167 			result = btv->radio_ctrl_handler.error;
4168 			goto fail2;
4169 		}
4170 		set_input(btv, 0, btv->tvnorm);
4171 		bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4172 		btv->crop[1] = btv->crop[0]; /* current = default */
4173 		disclaim_vbi_lines(btv);
4174 		disclaim_video_lines(btv);
4175 		bttv_register_video(btv);
4176 	}
4177 
4178 	/* add subdevices and autoload dvb-bt8xx if needed */
4179 	if (bttv_tvcards[btv->c.type].has_dvb) {
4180 		bttv_sub_add_device(&btv->c, "dvb");
4181 		request_modules(btv);
4182 	}
4183 
4184 	if (!disable_ir) {
4185 		init_bttv_i2c_ir(btv);
4186 		bttv_input_init(btv);
4187 	}
4188 
4189 	/* everything is fine */
4190 	bttv_num++;
4191 	return 0;
4192 
4193 fail2:
4194 	free_irq(btv->c.pci->irq,btv);
4195 
4196 fail1:
4197 	v4l2_ctrl_handler_free(&btv->ctrl_handler);
4198 	v4l2_ctrl_handler_free(&btv->radio_ctrl_handler);
4199 	v4l2_device_unregister(&btv->c.v4l2_dev);
4200 
4201 fail0:
4202 	if (btv->bt848_mmio)
4203 		iounmap(btv->bt848_mmio);
4204 	release_mem_region(pci_resource_start(btv->c.pci,0),
4205 			   pci_resource_len(btv->c.pci,0));
4206 	pci_disable_device(btv->c.pci);
4207 
4208 free_mem:
4209 	bttvs[btv->c.nr] = NULL;
4210 	kfree(btv);
4211 	return result;
4212 }
4213 
bttv_remove(struct pci_dev * pci_dev)4214 static void bttv_remove(struct pci_dev *pci_dev)
4215 {
4216 	struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4217 	struct bttv *btv = to_bttv(v4l2_dev);
4218 
4219 	if (bttv_verbose)
4220 		pr_info("%d: unloading\n", btv->c.nr);
4221 
4222 	if (bttv_tvcards[btv->c.type].has_dvb)
4223 		flush_request_modules(btv);
4224 
4225 	/* shutdown everything (DMA+IRQs) */
4226 	btand(~15, BT848_GPIO_DMA_CTL);
4227 	btwrite(0, BT848_INT_MASK);
4228 	btwrite(~0x0, BT848_INT_STAT);
4229 	btwrite(0x0, BT848_GPIO_OUT_EN);
4230 	if (bttv_gpio)
4231 		bttv_gpio_tracking(btv,"cleanup");
4232 
4233 	/* tell gpio modules we are leaving ... */
4234 	btv->shutdown=1;
4235 	bttv_input_fini(btv);
4236 	bttv_sub_del_devices(&btv->c);
4237 
4238 	/* unregister i2c_bus + input */
4239 	fini_bttv_i2c(btv);
4240 
4241 	/* unregister video4linux */
4242 	bttv_unregister_video(btv);
4243 
4244 	/* free allocated memory */
4245 	v4l2_ctrl_handler_free(&btv->ctrl_handler);
4246 	v4l2_ctrl_handler_free(&btv->radio_ctrl_handler);
4247 	btcx_riscmem_free(btv->c.pci,&btv->main);
4248 
4249 	/* free resources */
4250 	free_irq(btv->c.pci->irq,btv);
4251 	iounmap(btv->bt848_mmio);
4252 	release_mem_region(pci_resource_start(btv->c.pci,0),
4253 			   pci_resource_len(btv->c.pci,0));
4254 	pci_disable_device(btv->c.pci);
4255 
4256 	v4l2_device_unregister(&btv->c.v4l2_dev);
4257 	bttvs[btv->c.nr] = NULL;
4258 	kfree(btv);
4259 
4260 	return;
4261 }
4262 
bttv_suspend(struct device * dev)4263 static int __maybe_unused bttv_suspend(struct device *dev)
4264 {
4265 	struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
4266 	struct bttv *btv = to_bttv(v4l2_dev);
4267 	struct bttv_buffer_set idle;
4268 	unsigned long flags;
4269 
4270 	dprintk("%d: suspend\n", btv->c.nr);
4271 
4272 	/* stop dma + irqs */
4273 	spin_lock_irqsave(&btv->s_lock,flags);
4274 	memset(&idle, 0, sizeof(idle));
4275 	btv->state.video = btv->curr;
4276 	btv->state.vbi   = btv->cvbi;
4277 	btv->state.loop_irq = btv->loop_irq;
4278 	btv->curr = idle;
4279 	btv->loop_irq = 0;
4280 	bttv_buffer_activate_video(btv, &idle);
4281 	bttv_buffer_activate_vbi(btv, NULL);
4282 	bttv_set_dma(btv, 0);
4283 	btwrite(0, BT848_INT_MASK);
4284 	spin_unlock_irqrestore(&btv->s_lock,flags);
4285 
4286 	/* save bt878 state */
4287 	btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4288 	btv->state.gpio_data   = gpio_read();
4289 
4290 	btv->state.disabled = 1;
4291 	return 0;
4292 }
4293 
bttv_resume(struct device * dev)4294 static int __maybe_unused bttv_resume(struct device *dev)
4295 {
4296 	struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
4297 	struct bttv *btv = to_bttv(v4l2_dev);
4298 	unsigned long flags;
4299 
4300 	dprintk("%d: resume\n", btv->c.nr);
4301 
4302 	btv->state.disabled = 0;
4303 
4304 	/* restore bt878 state */
4305 	bttv_reinit_bt848(btv);
4306 	gpio_inout(0xffffff, btv->state.gpio_enable);
4307 	gpio_write(btv->state.gpio_data);
4308 
4309 	/* restart dma */
4310 	spin_lock_irqsave(&btv->s_lock,flags);
4311 	btv->curr = btv->state.video;
4312 	btv->cvbi = btv->state.vbi;
4313 	btv->loop_irq = btv->state.loop_irq;
4314 	bttv_buffer_activate_video(btv, &btv->curr);
4315 	bttv_buffer_activate_vbi(btv, btv->cvbi);
4316 	bttv_set_dma(btv, 0);
4317 	spin_unlock_irqrestore(&btv->s_lock,flags);
4318 	return 0;
4319 }
4320 
4321 static const struct pci_device_id bttv_pci_tbl[] = {
4322 	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0},
4323 	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0},
4324 	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0},
4325 	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0},
4326 	{PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_FUSION879), 0},
4327 	{0,}
4328 };
4329 
4330 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4331 
4332 static SIMPLE_DEV_PM_OPS(bttv_pm_ops,
4333 			 bttv_suspend,
4334 			 bttv_resume);
4335 
4336 static struct pci_driver bttv_pci_driver = {
4337 	.name      = "bttv",
4338 	.id_table  = bttv_pci_tbl,
4339 	.probe     = bttv_probe,
4340 	.remove    = bttv_remove,
4341 	.driver.pm = &bttv_pm_ops,
4342 };
4343 
bttv_init_module(void)4344 static int __init bttv_init_module(void)
4345 {
4346 	int ret;
4347 
4348 	bttv_num = 0;
4349 
4350 	pr_info("driver version %s loaded\n", BTTV_VERSION);
4351 	if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4352 		gbuffers = 2;
4353 	if (gbufsize > BTTV_MAX_FBUF)
4354 		gbufsize = BTTV_MAX_FBUF;
4355 	gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4356 	if (bttv_verbose)
4357 		pr_info("using %d buffers with %dk (%d pages) each for capture\n",
4358 			gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4359 
4360 	bttv_check_chipset();
4361 
4362 	ret = bus_register(&bttv_sub_bus_type);
4363 	if (ret < 0) {
4364 		pr_warn("bus_register error: %d\n", ret);
4365 		return ret;
4366 	}
4367 	ret = pci_register_driver(&bttv_pci_driver);
4368 	if (ret < 0)
4369 		bus_unregister(&bttv_sub_bus_type);
4370 
4371 	return ret;
4372 }
4373 
bttv_cleanup_module(void)4374 static void __exit bttv_cleanup_module(void)
4375 {
4376 	pci_unregister_driver(&bttv_pci_driver);
4377 	bus_unregister(&bttv_sub_bus_type);
4378 }
4379 
4380 module_init(bttv_init_module);
4381 module_exit(bttv_cleanup_module);
4382