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