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