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