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