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