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