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