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