?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[ARM] pxa: Gumstix Verdex PCMCIA support
[linux-2.6/verdex.git] / drivers / media / video / bt8xx / bttv-driver.c
blob939d1e5129746a1d3cfece3ec5f36b1332fdc0f2
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 if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3804 if (NULL == set->top &&
3805 V4L2_FIELD_TOP == item->vb.field) {
3806 set->top = item;
3807 }
3808 if (NULL == set->bottom &&
3809 V4L2_FIELD_BOTTOM == item->vb.field) {
3810 set->bottom = item;
3811 }
3812 if (NULL != set->top && NULL != set->bottom)
3813 set->top_irq = 2;
3814 }
3815 }
3816 }
3817
3818 /* screen overlay ? */
3819 if (NULL != btv->screen) {
3820 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3821 if (NULL == set->top && NULL == set->bottom) {
3822 set->top = btv->screen;
3823 set->bottom = btv->screen;
3824 }
3825 } else {
3826 if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3827 NULL == set->top) {
3828 set->top = btv->screen;
3829 }
3830 if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3831 NULL == set->bottom) {
3832 set->bottom = btv->screen;
3833 }
3834 }
3835 }
3836
3837 dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3838 btv->c.nr,set->top, set->bottom,
3839 btv->screen,set->frame_irq,set->top_irq);
3840 return 0;
3841 }
3842
3843 static void
3844 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3845 struct bttv_buffer_set *curr, unsigned int state)
3846 {
3847 struct timeval ts;
3848
3849 do_gettimeofday(&ts);
3850
3851 if (wakeup->top == wakeup->bottom) {
3852 if (NULL != wakeup->top && curr->top != wakeup->top) {
3853 if (irq_debug > 1)
3854 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
3855 wakeup->top->vb.ts = ts;
3856 wakeup->top->vb.field_count = btv->field_count;
3857 wakeup->top->vb.state = state;
3858 wake_up(&wakeup->top->vb.done);
3859 }
3860 } else {
3861 if (NULL != wakeup->top && curr->top != wakeup->top) {
3862 if (irq_debug > 1)
3863 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
3864 wakeup->top->vb.ts = ts;
3865 wakeup->top->vb.field_count = btv->field_count;
3866 wakeup->top->vb.state = state;
3867 wake_up(&wakeup->top->vb.done);
3868 }
3869 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3870 if (irq_debug > 1)
3871 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
3872 wakeup->bottom->vb.ts = ts;
3873 wakeup->bottom->vb.field_count = btv->field_count;
3874 wakeup->bottom->vb.state = state;
3875 wake_up(&wakeup->bottom->vb.done);
3876 }
3877 }
3878 }
3879
3880 static void
3881 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3882 unsigned int state)
3883 {
3884 struct timeval ts;
3885
3886 if (NULL == wakeup)
3887 return;
3888
3889 do_gettimeofday(&ts);
3890 wakeup->vb.ts = ts;
3891 wakeup->vb.field_count = btv->field_count;
3892 wakeup->vb.state = state;
3893 wake_up(&wakeup->vb.done);
3894 }
3895
3896 static void bttv_irq_timeout(unsigned long data)
3897 {
3898 struct bttv *btv = (struct bttv *)data;
3899 struct bttv_buffer_set old,new;
3900 struct bttv_buffer *ovbi;
3901 struct bttv_buffer *item;
3902 unsigned long flags;
3903
3904 if (bttv_verbose) {
3905 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3906 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3907 btread(BT848_RISC_COUNT));
3908 bttv_print_irqbits(btread(BT848_INT_STAT),0);
3909 printk("\n");
3910 }
3911
3912 spin_lock_irqsave(&btv->s_lock,flags);
3913
3914 /* deactivate stuff */
3915 memset(&new,0,sizeof(new));
3916 old = btv->curr;
3917 ovbi = btv->cvbi;
3918 btv->curr = new;
3919 btv->cvbi = NULL;
3920 btv->loop_irq = 0;
3921 bttv_buffer_activate_video(btv, &new);
3922 bttv_buffer_activate_vbi(btv, NULL);
3923 bttv_set_dma(btv, 0);
3924
3925 /* wake up */
3926 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
3927 bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
3928
3929 /* cancel all outstanding capture / vbi requests */
3930 while (!list_empty(&btv->capture)) {
3931 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3932 list_del(&item->vb.queue);
3933 item->vb.state = VIDEOBUF_ERROR;
3934 wake_up(&item->vb.done);
3935 }
3936 while (!list_empty(&btv->vcapture)) {
3937 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3938 list_del(&item->vb.queue);
3939 item->vb.state = VIDEOBUF_ERROR;
3940 wake_up(&item->vb.done);
3941 }
3942
3943 btv->errors++;
3944 spin_unlock_irqrestore(&btv->s_lock,flags);
3945 }
3946
3947 static void
3948 bttv_irq_wakeup_top(struct bttv *btv)
3949 {
3950 struct bttv_buffer *wakeup = btv->curr.top;
3951
3952 if (NULL == wakeup)
3953 return;
3954
3955 spin_lock(&btv->s_lock);
3956 btv->curr.top_irq = 0;
3957 btv->curr.top = NULL;
3958 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3959
3960 do_gettimeofday(&wakeup->vb.ts);
3961 wakeup->vb.field_count = btv->field_count;
3962 wakeup->vb.state = VIDEOBUF_DONE;
3963 wake_up(&wakeup->vb.done);
3964 spin_unlock(&btv->s_lock);
3965 }
3966
3967 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
3968 {
3969 if (rc < risc->dma)
3970 return 0;
3971 if (rc > risc->dma + risc->size)
3972 return 0;
3973 return 1;
3974 }
3975
3976 static void
3977 bttv_irq_switch_video(struct bttv *btv)
3978 {
3979 struct bttv_buffer_set new;
3980 struct bttv_buffer_set old;
3981 dma_addr_t rc;
3982
3983 spin_lock(&btv->s_lock);
3984
3985 /* new buffer set */
3986 bttv_irq_next_video(btv, &new);
3987 rc = btread(BT848_RISC_COUNT);
3988 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) ||
3989 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
3990 btv->framedrop++;
3991 if (debug_latency)
3992 bttv_irq_debug_low_latency(btv, rc);
3993 spin_unlock(&btv->s_lock);
3994 return;
3995 }
3996
3997 /* switch over */
3998 old = btv->curr;
3999 btv->curr = new;
4000 btv->loop_irq &= ~1;
4001 bttv_buffer_activate_video(btv, &new);
4002 bttv_set_dma(btv, 0);
4003
4004 /* switch input */
4005 if (UNSET != btv->new_input) {
4006 video_mux(btv,btv->new_input);
4007 btv->new_input = UNSET;
4008 }
4009
4010 /* wake up finished buffers */
4011 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
4012 spin_unlock(&btv->s_lock);
4013 }
4014
4015 static void
4016 bttv_irq_switch_vbi(struct bttv *btv)
4017 {
4018 struct bttv_buffer *new = NULL;
4019 struct bttv_buffer *old;
4020 u32 rc;
4021
4022 spin_lock(&btv->s_lock);
4023
4024 if (!list_empty(&btv->vcapture))
4025 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4026 old = btv->cvbi;
4027
4028 rc = btread(BT848_RISC_COUNT);
4029 if (NULL != old && (is_active(&old->top, rc) ||
4030 is_active(&old->bottom, rc))) {
4031 btv->framedrop++;
4032 if (debug_latency)
4033 bttv_irq_debug_low_latency(btv, rc);
4034 spin_unlock(&btv->s_lock);
4035 return;
4036 }
4037
4038 /* switch */
4039 btv->cvbi = new;
4040 btv->loop_irq &= ~4;
4041 bttv_buffer_activate_vbi(btv, new);
4042 bttv_set_dma(btv, 0);
4043
4044 bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
4045 spin_unlock(&btv->s_lock);
4046 }
4047
4048 static irqreturn_t bttv_irq(int irq, void *dev_id)
4049 {
4050 u32 stat,astat;
4051 u32 dstat;
4052 int count;
4053 struct bttv *btv;
4054 int handled = 0;
4055
4056 btv=(struct bttv *)dev_id;
4057
4058 if (btv->custom_irq)
4059 handled = btv->custom_irq(btv);
4060
4061 count=0;
4062 while (1) {
4063 /* get/clear interrupt status bits */
4064 stat=btread(BT848_INT_STAT);
4065 astat=stat&btread(BT848_INT_MASK);
4066 if (!astat)
4067 break;
4068 handled = 1;
4069 btwrite(stat,BT848_INT_STAT);
4070
4071 /* get device status bits */
4072 dstat=btread(BT848_DSTATUS);
4073
4074 if (irq_debug) {
4075 printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
4076 "riscs=%x, riscc=%08x, ",
4077 btv->c.nr, count, btv->field_count,
4078 stat>>28, btread(BT848_RISC_COUNT));
4079 bttv_print_irqbits(stat,astat);
4080 if (stat & BT848_INT_HLOCK)
4081 printk(" HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
4082 ? "yes" : "no");
4083 if (stat & BT848_INT_VPRES)
4084 printk(" PRES => %s", (dstat & BT848_DSTATUS_PRES)
4085 ? "yes" : "no");
4086 if (stat & BT848_INT_FMTCHG)
4087 printk(" NUML => %s", (dstat & BT848_DSTATUS_NUML)
4088 ? "625" : "525");
4089 printk("\n");
4090 }
4091
4092 if (astat&BT848_INT_VSYNC)
4093 btv->field_count++;
4094
4095 if ((astat & BT848_INT_GPINT) && btv->remote) {
4096 wake_up(&btv->gpioq);
4097 bttv_input_irq(btv);
4098 }
4099
4100 if (astat & BT848_INT_I2CDONE) {
4101 btv->i2c_done = stat;
4102 wake_up(&btv->i2c_queue);
4103 }
4104
4105 if ((astat & BT848_INT_RISCI) && (stat & (4<<28)))
4106 bttv_irq_switch_vbi(btv);
4107
4108 if ((astat & BT848_INT_RISCI) && (stat & (2<<28)))
4109 bttv_irq_wakeup_top(btv);
4110
4111 if ((astat & BT848_INT_RISCI) && (stat & (1<<28)))
4112 bttv_irq_switch_video(btv);
4113
4114 if ((astat & BT848_INT_HLOCK) && btv->opt_automute)
4115 audio_mute(btv, btv->mute); /* trigger automute */
4116
4117 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
4118 printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
4119 (astat & BT848_INT_SCERR) ? "SCERR" : "",
4120 (astat & BT848_INT_OCERR) ? "OCERR" : "",
4121 btread(BT848_RISC_COUNT));
4122 bttv_print_irqbits(stat,astat);
4123 printk("\n");
4124 if (bttv_debug)
4125 bttv_print_riscaddr(btv);
4126 }
4127 if (fdsr && astat & BT848_INT_FDSR) {
4128 printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
4129 btv->c.nr,btread(BT848_RISC_COUNT));
4130 if (bttv_debug)
4131 bttv_print_riscaddr(btv);
4132 }
4133
4134 count++;
4135 if (count > 4) {
4136
4137 if (count > 8 || !(astat & BT848_INT_GPINT)) {
4138 btwrite(0, BT848_INT_MASK);
4139
4140 printk(KERN_ERR
4141 "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
4142 } else {
4143 printk(KERN_ERR
4144 "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
4145
4146 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
4147 BT848_INT_MASK);
4148 };
4149
4150 bttv_print_irqbits(stat,astat);
4151
4152 printk("]\n");
4153 }
4154 }
4155 btv->irq_total++;
4156 if (handled)
4157 btv->irq_me++;
4158 return IRQ_RETVAL(handled);
4159 }
4160
4161
4162 /* ----------------------------------------------------------------------- */
4163 /* initialitation */
4164
4165 static struct video_device *vdev_init(struct bttv *btv,
4166 const struct video_device *template,
4167 const char *type_name)
4168 {
4169 struct video_device *vfd;
4170
4171 vfd = video_device_alloc();
4172 if (NULL == vfd)
4173 return NULL;
4174 *vfd = *template;
4175 vfd->v4l2_dev = &btv->c.v4l2_dev;
4176 vfd->release = video_device_release;
4177 vfd->debug = bttv_debug;
4178 video_set_drvdata(vfd, btv);
4179 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
4180 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
4181 type_name, bttv_tvcards[btv->c.type].name);
4182 return vfd;
4183 }
4184
4185 static void bttv_unregister_video(struct bttv *btv)
4186 {
4187 if (btv->video_dev) {
4188 if (-1 != btv->video_dev->minor)
4189 video_unregister_device(btv->video_dev);
4190 else
4191 video_device_release(btv->video_dev);
4192 btv->video_dev = NULL;
4193 }
4194 if (btv->vbi_dev) {
4195 if (-1 != btv->vbi_dev->minor)
4196 video_unregister_device(btv->vbi_dev);
4197 else
4198 video_device_release(btv->vbi_dev);
4199 btv->vbi_dev = NULL;
4200 }
4201 if (btv->radio_dev) {
4202 if (-1 != btv->radio_dev->minor)
4203 video_unregister_device(btv->radio_dev);
4204 else
4205 video_device_release(btv->radio_dev);
4206 btv->radio_dev = NULL;
4207 }
4208 }
4209
4210 /* register video4linux devices */
4211 static int __devinit bttv_register_video(struct bttv *btv)
4212 {
4213 if (no_overlay > 0)
4214 printk("bttv: Overlay support disabled.\n");
4215
4216 /* video */
4217 btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
4218
4219 if (NULL == btv->video_dev)
4220 goto err;
4221 if (video_register_device(btv->video_dev, VFL_TYPE_GRABBER,
4222 video_nr[btv->c.nr]) < 0)
4223 goto err;
4224 printk(KERN_INFO "bttv%d: registered device video%d\n",
4225 btv->c.nr, btv->video_dev->num);
4226 if (device_create_file(&btv->video_dev->dev,
4227 &dev_attr_card)<0) {
4228 printk(KERN_ERR "bttv%d: device_create_file 'card' "
4229 "failed\n", btv->c.nr);
4230 goto err;
4231 }
4232
4233 /* vbi */
4234 btv->vbi_dev = vdev_init(btv, &bttv_video_template, "vbi");
4235
4236 if (NULL == btv->vbi_dev)
4237 goto err;
4238 if (video_register_device(btv->vbi_dev, VFL_TYPE_VBI,
4239 vbi_nr[btv->c.nr]) < 0)
4240 goto err;
4241 printk(KERN_INFO "bttv%d: registered device vbi%d\n",
4242 btv->c.nr, btv->vbi_dev->num);
4243
4244 if (!btv->has_radio)
4245 return 0;
4246 /* radio */
4247 btv->radio_dev = vdev_init(btv, &radio_template, "radio");
4248 if (NULL == btv->radio_dev)
4249 goto err;
4250 if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,
4251 radio_nr[btv->c.nr]) < 0)
4252 goto err;
4253 printk(KERN_INFO "bttv%d: registered device radio%d\n",
4254 btv->c.nr, btv->radio_dev->num);
4255
4256 /* all done */
4257 return 0;
4258
4259 err:
4260 bttv_unregister_video(btv);
4261 return -1;
4262 }
4263
4264
4265 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
4266 /* response on cards with no firmware is not enabled by OF */
4267 static void pci_set_command(struct pci_dev *dev)
4268 {
4269 #if defined(__powerpc__)
4270 unsigned int cmd;
4271
4272 pci_read_config_dword(dev, PCI_COMMAND, &cmd);
4273 cmd = (cmd | PCI_COMMAND_MEMORY );
4274 pci_write_config_dword(dev, PCI_COMMAND, cmd);
4275 #endif
4276 }
4277
4278 static int __devinit bttv_probe(struct pci_dev *dev,
4279 const struct pci_device_id *pci_id)
4280 {
4281 int result;
4282 unsigned char lat;
4283 struct bttv *btv;
4284
4285 if (bttv_num == BTTV_MAX)
4286 return -ENOMEM;
4287 printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
4288 bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL);
4289 if (btv == NULL) {
4290 printk(KERN_ERR "bttv: out of memory.\n");
4291 return -ENOMEM;
4292 }
4293 btv->c.nr = bttv_num;
4294 snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name),
4295 "bttv%d", btv->c.nr);
4296
4297 /* initialize structs / fill in defaults */
4298 mutex_init(&btv->lock);
4299 spin_lock_init(&btv->s_lock);
4300 spin_lock_init(&btv->gpio_lock);
4301 init_waitqueue_head(&btv->gpioq);
4302 init_waitqueue_head(&btv->i2c_queue);
4303 INIT_LIST_HEAD(&btv->c.subs);
4304 INIT_LIST_HEAD(&btv->capture);
4305 INIT_LIST_HEAD(&btv->vcapture);
4306 v4l2_prio_init(&btv->prio);
4307
4308 init_timer(&btv->timeout);
4309 btv->timeout.function = bttv_irq_timeout;
4310 btv->timeout.data = (unsigned long)btv;
4311
4312 btv->i2c_rc = -1;
4313 btv->tuner_type = UNSET;
4314 btv->new_input = UNSET;
4315 btv->has_radio=radio[btv->c.nr];
4316
4317 /* pci stuff (init, get irq/mmio, ... */
4318 btv->c.pci = dev;
4319 btv->id = dev->device;
4320 if (pci_enable_device(dev)) {
4321 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4322 btv->c.nr);
4323 return -EIO;
4324 }
4325 if (pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
4326 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
4327 btv->c.nr);
4328 return -EIO;
4329 }
4330 if (!request_mem_region(pci_resource_start(dev,0),
4331 pci_resource_len(dev,0),
4332 btv->c.v4l2_dev.name)) {
4333 printk(KERN_WARNING "bttv%d: can't request iomem (0x%llx).\n",
4334 btv->c.nr,
4335 (unsigned long long)pci_resource_start(dev,0));
4336 return -EBUSY;
4337 }
4338 pci_set_master(dev);
4339 pci_set_command(dev);
4340
4341 result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev);
4342 if (result < 0) {
4343 printk(KERN_WARNING "bttv%d: v4l2_device_register() failed\n", btv->c.nr);
4344 goto fail0;
4345 }
4346
4347 pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
4348 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4349 printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
4350 bttv_num,btv->id, btv->revision, pci_name(dev));
4351 printk("irq: %d, latency: %d, mmio: 0x%llx\n",
4352 btv->c.pci->irq, lat,
4353 (unsigned long long)pci_resource_start(dev,0));
4354 schedule();
4355
4356 btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4357 if (NULL == btv->bt848_mmio) {
4358 printk("bttv%d: ioremap() failed\n", btv->c.nr);
4359 result = -EIO;
4360 goto fail1;
4361 }
4362
4363 /* identify card */
4364 bttv_idcard(btv);
4365
4366 /* disable irqs, register irq handler */
4367 btwrite(0, BT848_INT_MASK);
4368 result = request_irq(btv->c.pci->irq, bttv_irq,
4369 IRQF_SHARED | IRQF_DISABLED, btv->c.v4l2_dev.name, (void *)btv);
4370 if (result < 0) {
4371 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
4372 bttv_num,btv->c.pci->irq);
4373 goto fail1;
4374 }
4375
4376 if (0 != bttv_handle_chipset(btv)) {
4377 result = -EIO;
4378 goto fail2;
4379 }
4380
4381 /* init options from insmod args */
4382 btv->opt_combfilter = combfilter;
4383 btv->opt_lumafilter = lumafilter;
4384 btv->opt_automute = automute;
4385 btv->opt_chroma_agc = chroma_agc;
4386 btv->opt_adc_crush = adc_crush;
4387 btv->opt_vcr_hack = vcr_hack;
4388 btv->opt_whitecrush_upper = whitecrush_upper;
4389 btv->opt_whitecrush_lower = whitecrush_lower;
4390 btv->opt_uv_ratio = uv_ratio;
4391 btv->opt_full_luma_range = full_luma_range;
4392 btv->opt_coring = coring;
4393
4394 /* fill struct bttv with some useful defaults */
4395 btv->init.btv = btv;
4396 btv->init.ov.w.width = 320;
4397 btv->init.ov.w.height = 240;
4398 btv->init.fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24);
4399 btv->init.width = 320;
4400 btv->init.height = 240;
4401 btv->input = 0;
4402
4403 /* initialize hardware */
4404 if (bttv_gpio)
4405 bttv_gpio_tracking(btv,"pre-init");
4406
4407 bttv_risc_init_main(btv);
4408 init_bt848(btv);
4409
4410 /* gpio */
4411 btwrite(0x00, BT848_GPIO_REG_INP);
4412 btwrite(0x00, BT848_GPIO_OUT_EN);
4413 if (bttv_verbose)
4414 bttv_gpio_tracking(btv,"init");
4415
4416 /* needs to be done before i2c is registered */
4417 bttv_init_card1(btv);
4418
4419 /* register i2c + gpio */
4420 init_bttv_i2c(btv);
4421
4422 /* some card-specific stuff (needs working i2c) */
4423 bttv_init_card2(btv);
4424 bttv_init_tuner(btv);
4425 init_irqreg(btv);
4426
4427 /* register video4linux + input */
4428 if (!bttv_tvcards[btv->c.type].no_video) {
4429 bttv_register_video(btv);
4430 bt848_bright(btv,32768);
4431 bt848_contrast(btv,32768);
4432 bt848_hue(btv,32768);
4433 bt848_sat(btv,32768);
4434 audio_mute(btv, 1);
4435 set_input(btv, 0, btv->tvnorm);
4436 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4437 btv->crop[1] = btv->crop[0]; /* current = default */
4438 disclaim_vbi_lines(btv);
4439 disclaim_video_lines(btv);
4440 }
4441
4442 /* add subdevices and autoload dvb-bt8xx if needed */
4443 if (bttv_tvcards[btv->c.type].has_dvb) {
4444 bttv_sub_add_device(&btv->c, "dvb");
4445 request_modules(btv);
4446 }
4447
4448 bttv_input_init(btv);
4449
4450 /* everything is fine */
4451 bttv_num++;
4452 return 0;
4453
4454 fail2:
4455 free_irq(btv->c.pci->irq,btv);
4456
4457 fail1:
4458 v4l2_device_unregister(&btv->c.v4l2_dev);
4459
4460 fail0:
4461 if (btv->bt848_mmio)
4462 iounmap(btv->bt848_mmio);
4463 release_mem_region(pci_resource_start(btv->c.pci,0),
4464 pci_resource_len(btv->c.pci,0));
4465 return result;
4466 }
4467
4468 static void __devexit bttv_remove(struct pci_dev *pci_dev)
4469 {
4470 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4471 struct bttv *btv = to_bttv(v4l2_dev);
4472
4473 if (bttv_verbose)
4474 printk("bttv%d: unloading\n",btv->c.nr);
4475
4476 /* shutdown everything (DMA+IRQs) */
4477 btand(~15, BT848_GPIO_DMA_CTL);
4478 btwrite(0, BT848_INT_MASK);
4479 btwrite(~0x0, BT848_INT_STAT);
4480 btwrite(0x0, BT848_GPIO_OUT_EN);
4481 if (bttv_gpio)
4482 bttv_gpio_tracking(btv,"cleanup");
4483
4484 /* tell gpio modules we are leaving ... */
4485 btv->shutdown=1;
4486 wake_up(&btv->gpioq);
4487 bttv_input_fini(btv);
4488 bttv_sub_del_devices(&btv->c);
4489
4490 /* unregister i2c_bus + input */
4491 fini_bttv_i2c(btv);
4492
4493 /* unregister video4linux */
4494 bttv_unregister_video(btv);
4495
4496 /* free allocated memory */
4497 btcx_riscmem_free(btv->c.pci,&btv->main);
4498
4499 /* free ressources */
4500 free_irq(btv->c.pci->irq,btv);
4501 iounmap(btv->bt848_mmio);
4502 release_mem_region(pci_resource_start(btv->c.pci,0),
4503 pci_resource_len(btv->c.pci,0));
4504
4505 v4l2_device_unregister(&btv->c.v4l2_dev);
4506 bttvs[btv->c.nr] = NULL;
4507 kfree(btv);
4508
4509 return;
4510 }
4511
4512 #ifdef CONFIG_PM
4513 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4514 {
4515 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4516 struct bttv *btv = to_bttv(v4l2_dev);
4517 struct bttv_buffer_set idle;
4518 unsigned long flags;
4519
4520 dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
4521
4522 /* stop dma + irqs */
4523 spin_lock_irqsave(&btv->s_lock,flags);
4524 memset(&idle, 0, sizeof(idle));
4525 btv->state.video = btv->curr;
4526 btv->state.vbi = btv->cvbi;
4527 btv->state.loop_irq = btv->loop_irq;
4528 btv->curr = idle;
4529 btv->loop_irq = 0;
4530 bttv_buffer_activate_video(btv, &idle);
4531 bttv_buffer_activate_vbi(btv, NULL);
4532 bttv_set_dma(btv, 0);
4533 btwrite(0, BT848_INT_MASK);
4534 spin_unlock_irqrestore(&btv->s_lock,flags);
4535
4536 /* save bt878 state */
4537 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4538 btv->state.gpio_data = gpio_read();
4539
4540 /* save pci state */
4541 pci_save_state(pci_dev);
4542 if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4543 pci_disable_device(pci_dev);
4544 btv->state.disabled = 1;
4545 }
4546 return 0;
4547 }
4548
4549 static int bttv_resume(struct pci_dev *pci_dev)
4550 {
4551 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4552 struct bttv *btv = to_bttv(v4l2_dev);
4553 unsigned long flags;
4554 int err;
4555
4556 dprintk("bttv%d: resume\n", btv->c.nr);
4557
4558 /* restore pci state */
4559 if (btv->state.disabled) {
4560 err=pci_enable_device(pci_dev);
4561 if (err) {
4562 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4563 btv->c.nr);
4564 return err;
4565 }
4566 btv->state.disabled = 0;
4567 }
4568 err=pci_set_power_state(pci_dev, PCI_D0);
4569 if (err) {
4570 pci_disable_device(pci_dev);
4571 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4572 btv->c.nr);
4573 btv->state.disabled = 1;
4574 return err;
4575 }
4576
4577 pci_restore_state(pci_dev);
4578
4579 /* restore bt878 state */
4580 bttv_reinit_bt848(btv);
4581 gpio_inout(0xffffff, btv->state.gpio_enable);
4582 gpio_write(btv->state.gpio_data);
4583
4584 /* restart dma */
4585 spin_lock_irqsave(&btv->s_lock,flags);
4586 btv->curr = btv->state.video;
4587 btv->cvbi = btv->state.vbi;
4588 btv->loop_irq = btv->state.loop_irq;
4589 bttv_buffer_activate_video(btv, &btv->curr);
4590 bttv_buffer_activate_vbi(btv, btv->cvbi);
4591 bttv_set_dma(btv, 0);
4592 spin_unlock_irqrestore(&btv->s_lock,flags);
4593 return 0;
4594 }
4595 #endif
4596
4597 static struct pci_device_id bttv_pci_tbl[] = {
4598 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0},
4599 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0},
4600 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0},
4601 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0},
4602 {0,}
4603 };
4604
4605 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4606
4607 static struct pci_driver bttv_pci_driver = {
4608 .name = "bttv",
4609 .id_table = bttv_pci_tbl,
4610 .probe = bttv_probe,
4611 .remove = __devexit_p(bttv_remove),
4612 #ifdef CONFIG_PM
4613 .suspend = bttv_suspend,
4614 .resume = bttv_resume,
4615 #endif
4616 };
4617
4618 static int __init bttv_init_module(void)
4619 {
4620 int ret;
4621
4622 bttv_num = 0;
4623
4624 printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4625 (BTTV_VERSION_CODE >> 16) & 0xff,
4626 (BTTV_VERSION_CODE >> 8) & 0xff,
4627 BTTV_VERSION_CODE & 0xff);
4628 #ifdef SNAPSHOT
4629 printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4630 SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4631 #endif
4632 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4633 gbuffers = 2;
4634 if (gbufsize > BTTV_MAX_FBUF)
4635 gbufsize = BTTV_MAX_FBUF;
4636 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4637 if (bttv_verbose)
4638 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4639 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4640
4641 bttv_check_chipset();
4642
4643 ret = bus_register(&bttv_sub_bus_type);
4644 if (ret < 0) {
4645 printk(KERN_WARNING "bttv: bus_register error: %d\n", ret);
4646 return ret;
4647 }
4648 ret = pci_register_driver(&bttv_pci_driver);
4649 if (ret < 0)
4650 bus_unregister(&bttv_sub_bus_type);
4651
4652 return ret;
4653 }
4654
4655 static void __exit bttv_cleanup_module(void)
4656 {
4657 pci_unregister_driver(&bttv_pci_driver);
4658 bus_unregister(&bttv_sub_bus_type);
4659 }
4660
4661 module_init(bttv_init_module);
4662 module_exit(bttv_cleanup_module);
4663
4664 /*
4665 * Local variables:
4666 * c-basic-offset: 8
4667 * End:
4668 */
Verdex Pro support