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