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, ©, 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 del_timer_sync(&btv->timeout);
4252 iounmap(btv->bt848_mmio);
4253 release_mem_region(pci_resource_start(btv->c.pci,0),
4254 pci_resource_len(btv->c.pci,0));
4255 pci_disable_device(btv->c.pci);
4256
4257 v4l2_device_unregister(&btv->c.v4l2_dev);
4258 bttvs[btv->c.nr] = NULL;
4259 kfree(btv);
4260
4261 return;
4262 }
4263
bttv_suspend(struct device * dev)4264 static int __maybe_unused bttv_suspend(struct device *dev)
4265 {
4266 struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
4267 struct bttv *btv = to_bttv(v4l2_dev);
4268 struct bttv_buffer_set idle;
4269 unsigned long flags;
4270
4271 dprintk("%d: suspend\n", btv->c.nr);
4272
4273 /* stop dma + irqs */
4274 spin_lock_irqsave(&btv->s_lock,flags);
4275 memset(&idle, 0, sizeof(idle));
4276 btv->state.video = btv->curr;
4277 btv->state.vbi = btv->cvbi;
4278 btv->state.loop_irq = btv->loop_irq;
4279 btv->curr = idle;
4280 btv->loop_irq = 0;
4281 bttv_buffer_activate_video(btv, &idle);
4282 bttv_buffer_activate_vbi(btv, NULL);
4283 bttv_set_dma(btv, 0);
4284 btwrite(0, BT848_INT_MASK);
4285 spin_unlock_irqrestore(&btv->s_lock,flags);
4286
4287 /* save bt878 state */
4288 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4289 btv->state.gpio_data = gpio_read();
4290
4291 btv->state.disabled = 1;
4292 return 0;
4293 }
4294
bttv_resume(struct device * dev)4295 static int __maybe_unused bttv_resume(struct device *dev)
4296 {
4297 struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
4298 struct bttv *btv = to_bttv(v4l2_dev);
4299 unsigned long flags;
4300
4301 dprintk("%d: resume\n", btv->c.nr);
4302
4303 btv->state.disabled = 0;
4304
4305 /* restore bt878 state */
4306 bttv_reinit_bt848(btv);
4307 gpio_inout(0xffffff, btv->state.gpio_enable);
4308 gpio_write(btv->state.gpio_data);
4309
4310 /* restart dma */
4311 spin_lock_irqsave(&btv->s_lock,flags);
4312 btv->curr = btv->state.video;
4313 btv->cvbi = btv->state.vbi;
4314 btv->loop_irq = btv->state.loop_irq;
4315 bttv_buffer_activate_video(btv, &btv->curr);
4316 bttv_buffer_activate_vbi(btv, btv->cvbi);
4317 bttv_set_dma(btv, 0);
4318 spin_unlock_irqrestore(&btv->s_lock,flags);
4319 return 0;
4320 }
4321
4322 static const struct pci_device_id bttv_pci_tbl[] = {
4323 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0},
4324 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0},
4325 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0},
4326 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0},
4327 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_FUSION879), 0},
4328 {0,}
4329 };
4330
4331 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4332
4333 static SIMPLE_DEV_PM_OPS(bttv_pm_ops,
4334 bttv_suspend,
4335 bttv_resume);
4336
4337 static struct pci_driver bttv_pci_driver = {
4338 .name = "bttv",
4339 .id_table = bttv_pci_tbl,
4340 .probe = bttv_probe,
4341 .remove = bttv_remove,
4342 .driver.pm = &bttv_pm_ops,
4343 };
4344
bttv_init_module(void)4345 static int __init bttv_init_module(void)
4346 {
4347 int ret;
4348
4349 bttv_num = 0;
4350
4351 pr_info("driver version %s loaded\n", BTTV_VERSION);
4352 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4353 gbuffers = 2;
4354 if (gbufsize > BTTV_MAX_FBUF)
4355 gbufsize = BTTV_MAX_FBUF;
4356 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4357 if (bttv_verbose)
4358 pr_info("using %d buffers with %dk (%d pages) each for capture\n",
4359 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4360
4361 bttv_check_chipset();
4362
4363 ret = bus_register(&bttv_sub_bus_type);
4364 if (ret < 0) {
4365 pr_warn("bus_register error: %d\n", ret);
4366 return ret;
4367 }
4368 ret = pci_register_driver(&bttv_pci_driver);
4369 if (ret < 0)
4370 bus_unregister(&bttv_sub_bus_type);
4371
4372 return ret;
4373 }
4374
bttv_cleanup_module(void)4375 static void __exit bttv_cleanup_module(void)
4376 {
4377 pci_unregister_driver(&bttv_pci_driver);
4378 bus_unregister(&bttv_sub_bus_type);
4379 }
4380
4381 module_init(bttv_init_module);
4382 module_exit(bttv_cleanup_module);
4383