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