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