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