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