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