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