bttv: Width must be a multiple of 16 when capturing planar formats
[pandora-kernel.git] / drivers / media / video / bt8xx / bttv-driver.c
1 /*
2
3     bttv - Bt848 frame grabber driver
4
5     Copyright (C) 1996,97,98 Ralph  Metzler <rjkm@thp.uni-koeln.de>
6                            & Marcus Metzler <mocm@thp.uni-koeln.de>
7     (c) 1999-2002 Gerd Knorr <kraxel@bytesex.org>
8
9     some v4l2 code lines are taken from Justin's bttv2 driver which is
10     (c) 2000 Justin Schoeman <justin@suntiger.ee.up.ac.za>
11
12     V4L1 removal from:
13     (c) 2005-2006 Nickolay V. Shmyrev <nshmyrev@yandex.ru>
14
15     Fixes to be fully V4L2 compliant by
16     (c) 2006 Mauro Carvalho Chehab <mchehab@infradead.org>
17
18     Cropping and overscan support
19     Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
20     Sponsored by OPQ Systems AB
21
22     This program is free software; you can redistribute it and/or modify
23     it under the terms of the GNU General Public License as published by
24     the Free Software Foundation; either version 2 of the License, or
25     (at your option) any later version.
26
27     This program is distributed in the hope that it will be useful,
28     but WITHOUT ANY WARRANTY; without even the implied warranty of
29     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
30     GNU General Public License for more details.
31
32     You should have received a copy of the GNU General Public License
33     along with this program; if not, write to the Free Software
34     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
35 */
36
37 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
38
39 #include <linux/init.h>
40 #include <linux/module.h>
41 #include <linux/delay.h>
42 #include <linux/slab.h>
43 #include <linux/errno.h>
44 #include <linux/fs.h>
45 #include <linux/kernel.h>
46 #include <linux/sched.h>
47 #include <linux/interrupt.h>
48 #include <linux/kdev_t.h>
49 #include "bttvp.h"
50 #include <media/v4l2-common.h>
51 #include <media/v4l2-ioctl.h>
52 #include <media/tvaudio.h>
53 #include <media/msp3400.h>
54
55 #include <linux/dma-mapping.h>
56
57 #include <asm/io.h>
58 #include <asm/byteorder.h>
59
60 #include <media/saa6588.h>
61
62 #define BTTV_VERSION "0.9.19"
63
64 unsigned int bttv_num;                  /* number of Bt848s in use */
65 struct bttv *bttvs[BTTV_MAX];
66
67 unsigned int bttv_debug;
68 unsigned int bttv_verbose = 1;
69 unsigned int bttv_gpio;
70
71 /* config variables */
72 #ifdef __BIG_ENDIAN
73 static unsigned int bigendian=1;
74 #else
75 static unsigned int bigendian;
76 #endif
77 static unsigned int radio[BTTV_MAX];
78 static unsigned int irq_debug;
79 static unsigned int gbuffers = 8;
80 static unsigned int gbufsize = 0x208000;
81 static unsigned int reset_crop = 1;
82
83 static int video_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
84 static int radio_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
85 static int vbi_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
86 static int debug_latency;
87 static int disable_ir;
88
89 static unsigned int fdsr;
90
91 /* options */
92 static unsigned int combfilter;
93 static unsigned int lumafilter;
94 static unsigned int automute    = 1;
95 static unsigned int chroma_agc;
96 static unsigned int adc_crush   = 1;
97 static unsigned int whitecrush_upper = 0xCF;
98 static unsigned int whitecrush_lower = 0x7F;
99 static unsigned int vcr_hack;
100 static unsigned int irq_iswitch;
101 static unsigned int uv_ratio    = 50;
102 static unsigned int full_luma_range;
103 static unsigned int coring;
104
105 /* API features (turn on/off stuff for testing) */
106 static unsigned int v4l2        = 1;
107
108 /* insmod args */
109 module_param(bttv_verbose,      int, 0644);
110 module_param(bttv_gpio,         int, 0644);
111 module_param(bttv_debug,        int, 0644);
112 module_param(irq_debug,         int, 0644);
113 module_param(debug_latency,     int, 0644);
114 module_param(disable_ir,        int, 0444);
115
116 module_param(fdsr,              int, 0444);
117 module_param(gbuffers,          int, 0444);
118 module_param(gbufsize,          int, 0444);
119 module_param(reset_crop,        int, 0444);
120
121 module_param(v4l2,              int, 0644);
122 module_param(bigendian,         int, 0644);
123 module_param(irq_iswitch,       int, 0644);
124 module_param(combfilter,        int, 0444);
125 module_param(lumafilter,        int, 0444);
126 module_param(automute,          int, 0444);
127 module_param(chroma_agc,        int, 0444);
128 module_param(adc_crush,         int, 0444);
129 module_param(whitecrush_upper,  int, 0444);
130 module_param(whitecrush_lower,  int, 0444);
131 module_param(vcr_hack,          int, 0444);
132 module_param(uv_ratio,          int, 0444);
133 module_param(full_luma_range,   int, 0444);
134 module_param(coring,            int, 0444);
135
136 module_param_array(radio,       int, NULL, 0444);
137 module_param_array(video_nr,    int, NULL, 0444);
138 module_param_array(radio_nr,    int, NULL, 0444);
139 module_param_array(vbi_nr,      int, NULL, 0444);
140
141 MODULE_PARM_DESC(radio,"The TV card supports radio, default is 0 (no)");
142 MODULE_PARM_DESC(bigendian,"byte order of the framebuffer, default is native endian");
143 MODULE_PARM_DESC(bttv_verbose,"verbose startup messages, default is 1 (yes)");
144 MODULE_PARM_DESC(bttv_gpio,"log gpio changes, default is 0 (no)");
145 MODULE_PARM_DESC(bttv_debug,"debug messages, default is 0 (no)");
146 MODULE_PARM_DESC(irq_debug,"irq handler debug messages, default is 0 (no)");
147 MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
148 MODULE_PARM_DESC(gbuffers,"number of capture buffers. range 2-32, default 8");
149 MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 0x208000");
150 MODULE_PARM_DESC(reset_crop,"reset cropping parameters at open(), default "
151                  "is 1 (yes) for compatibility with older applications");
152 MODULE_PARM_DESC(automute,"mute audio on bad/missing video signal, default is 1 (yes)");
153 MODULE_PARM_DESC(chroma_agc,"enables the AGC of chroma signal, default is 0 (no)");
154 MODULE_PARM_DESC(adc_crush,"enables the luminance ADC crush, default is 1 (yes)");
155 MODULE_PARM_DESC(whitecrush_upper,"sets the white crush upper value, default is 207");
156 MODULE_PARM_DESC(whitecrush_lower,"sets the white crush lower value, default is 127");
157 MODULE_PARM_DESC(vcr_hack,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
158 MODULE_PARM_DESC(irq_iswitch,"switch inputs in irq handler");
159 MODULE_PARM_DESC(uv_ratio,"ratio between u and v gains, default is 50");
160 MODULE_PARM_DESC(full_luma_range,"use the full luma range, default is 0 (no)");
161 MODULE_PARM_DESC(coring,"set the luma coring level, default is 0 (no)");
162 MODULE_PARM_DESC(video_nr, "video device numbers");
163 MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
164 MODULE_PARM_DESC(radio_nr, "radio device numbers");
165
166 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
167 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
168 MODULE_LICENSE("GPL");
169 MODULE_VERSION(BTTV_VERSION);
170
171 /* ----------------------------------------------------------------------- */
172 /* sysfs                                                                   */
173
174 static ssize_t show_card(struct device *cd,
175                          struct device_attribute *attr, char *buf)
176 {
177         struct video_device *vfd = container_of(cd, struct video_device, dev);
178         struct bttv *btv = video_get_drvdata(vfd);
179         return sprintf(buf, "%d\n", btv ? btv->c.type : UNSET);
180 }
181 static DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
182
183 /* ----------------------------------------------------------------------- */
184 /* dvb auto-load setup                                                     */
185 #if defined(CONFIG_MODULES) && defined(MODULE)
186 static void request_module_async(struct work_struct *work)
187 {
188         request_module("dvb-bt8xx");
189 }
190
191 static void request_modules(struct bttv *dev)
192 {
193         INIT_WORK(&dev->request_module_wk, request_module_async);
194         schedule_work(&dev->request_module_wk);
195 }
196
197 static void flush_request_modules(struct bttv *dev)
198 {
199         flush_work_sync(&dev->request_module_wk);
200 }
201 #else
202 #define request_modules(dev)
203 #define flush_request_modules(dev)
204 #endif /* CONFIG_MODULES */
205
206
207 /* ----------------------------------------------------------------------- */
208 /* static data                                                             */
209
210 /* special timing tables from conexant... */
211 static u8 SRAM_Table[][60] =
212 {
213         /* PAL digital input over GPIO[7:0] */
214         {
215                 45, // 45 bytes following
216                 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
217                 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
218                 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
219                 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
220                 0x37,0x00,0xAF,0x21,0x00
221         },
222         /* NTSC digital input over GPIO[7:0] */
223         {
224                 51, // 51 bytes following
225                 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
226                 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
227                 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
228                 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
229                 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
230                 0x00,
231         },
232         // TGB_NTSC392 // quartzsight
233         // This table has been modified to be used for Fusion Rev D
234         {
235                 0x2A, // size of table = 42
236                 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
237                 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
238                 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
239                 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
240                 0x20, 0x00
241         }
242 };
243
244 /* minhdelayx1  first video pixel we can capture on a line and
245    hdelayx1     start of active video, both relative to rising edge of
246                 /HRESET pulse (0H) in 1 / fCLKx1.
247    swidth       width of active video and
248    totalwidth   total line width, both in 1 / fCLKx1.
249    sqwidth      total line width in square pixels.
250    vdelay       start of active video in 2 * field lines relative to
251                 trailing edge of /VRESET pulse (VDELAY register).
252    sheight      height of active video in 2 * field lines.
253    videostart0  ITU-R frame line number of the line corresponding
254                 to vdelay in the first field. */
255 #define CROPCAP(minhdelayx1, hdelayx1, swidth, totalwidth, sqwidth,      \
256                 vdelay, sheight, videostart0)                            \
257         .cropcap.bounds.left = minhdelayx1,                              \
258         /* * 2 because vertically we count field lines times two, */     \
259         /* e.g. 23 * 2 to 23 * 2 + 576 in PAL-BGHI defrect. */           \
260         .cropcap.bounds.top = (videostart0) * 2 - (vdelay) + MIN_VDELAY, \
261         /* 4 is a safety margin at the end of the line. */               \
262         .cropcap.bounds.width = (totalwidth) - (minhdelayx1) - 4,        \
263         .cropcap.bounds.height = (sheight) + (vdelay) - MIN_VDELAY,      \
264         .cropcap.defrect.left = hdelayx1,                                \
265         .cropcap.defrect.top = (videostart0) * 2,                        \
266         .cropcap.defrect.width = swidth,                                 \
267         .cropcap.defrect.height = sheight,                               \
268         .cropcap.pixelaspect.numerator = totalwidth,                     \
269         .cropcap.pixelaspect.denominator = sqwidth,
270
271 const struct bttv_tvnorm bttv_tvnorms[] = {
272         /* PAL-BDGHI */
273         /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
274         /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
275         {
276                 .v4l2_id        = V4L2_STD_PAL,
277                 .name           = "PAL",
278                 .Fsc            = 35468950,
279                 .swidth         = 924,
280                 .sheight        = 576,
281                 .totalwidth     = 1135,
282                 .adelay         = 0x7f,
283                 .bdelay         = 0x72,
284                 .iform          = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
285                 .scaledtwidth   = 1135,
286                 .hdelayx1       = 186,
287                 .hactivex1      = 924,
288                 .vdelay         = 0x20,
289                 .vbipack        = 255, /* min (2048 / 4, 0x1ff) & 0xff */
290                 .sram           = 0,
291                 /* ITU-R frame line number of the first VBI line
292                    we can capture, of the first and second field.
293                    The last line is determined by cropcap.bounds. */
294                 .vbistart       = { 7, 320 },
295                 CROPCAP(/* minhdelayx1 */ 68,
296                         /* hdelayx1 */ 186,
297                         /* Should be (768 * 1135 + 944 / 2) / 944.
298                            cropcap.defrect is used for image width
299                            checks, so we keep the old value 924. */
300                         /* swidth */ 924,
301                         /* totalwidth */ 1135,
302                         /* sqwidth */ 944,
303                         /* vdelay */ 0x20,
304                         /* sheight */ 576,
305                         /* videostart0 */ 23)
306                 /* bt878 (and bt848?) can capture another
307                    line below active video. */
308                 .cropcap.bounds.height = (576 + 2) + 0x20 - 2,
309         },{
310                 .v4l2_id        = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
311                 .name           = "NTSC",
312                 .Fsc            = 28636363,
313                 .swidth         = 768,
314                 .sheight        = 480,
315                 .totalwidth     = 910,
316                 .adelay         = 0x68,
317                 .bdelay         = 0x5d,
318                 .iform          = (BT848_IFORM_NTSC|BT848_IFORM_XT0),
319                 .scaledtwidth   = 910,
320                 .hdelayx1       = 128,
321                 .hactivex1      = 910,
322                 .vdelay         = 0x1a,
323                 .vbipack        = 144, /* min (1600 / 4, 0x1ff) & 0xff */
324                 .sram           = 1,
325                 .vbistart       = { 10, 273 },
326                 CROPCAP(/* minhdelayx1 */ 68,
327                         /* hdelayx1 */ 128,
328                         /* Should be (640 * 910 + 780 / 2) / 780? */
329                         /* swidth */ 768,
330                         /* totalwidth */ 910,
331                         /* sqwidth */ 780,
332                         /* vdelay */ 0x1a,
333                         /* sheight */ 480,
334                         /* videostart0 */ 23)
335         },{
336                 .v4l2_id        = V4L2_STD_SECAM,
337                 .name           = "SECAM",
338                 .Fsc            = 35468950,
339                 .swidth         = 924,
340                 .sheight        = 576,
341                 .totalwidth     = 1135,
342                 .adelay         = 0x7f,
343                 .bdelay         = 0xb0,
344                 .iform          = (BT848_IFORM_SECAM|BT848_IFORM_XT1),
345                 .scaledtwidth   = 1135,
346                 .hdelayx1       = 186,
347                 .hactivex1      = 922,
348                 .vdelay         = 0x20,
349                 .vbipack        = 255,
350                 .sram           = 0, /* like PAL, correct? */
351                 .vbistart       = { 7, 320 },
352                 CROPCAP(/* minhdelayx1 */ 68,
353                         /* hdelayx1 */ 186,
354                         /* swidth */ 924,
355                         /* totalwidth */ 1135,
356                         /* sqwidth */ 944,
357                         /* vdelay */ 0x20,
358                         /* sheight */ 576,
359                         /* videostart0 */ 23)
360         },{
361                 .v4l2_id        = V4L2_STD_PAL_Nc,
362                 .name           = "PAL-Nc",
363                 .Fsc            = 28636363,
364                 .swidth         = 640,
365                 .sheight        = 576,
366                 .totalwidth     = 910,
367                 .adelay         = 0x68,
368                 .bdelay         = 0x5d,
369                 .iform          = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
370                 .scaledtwidth   = 780,
371                 .hdelayx1       = 130,
372                 .hactivex1      = 734,
373                 .vdelay         = 0x1a,
374                 .vbipack        = 144,
375                 .sram           = -1,
376                 .vbistart       = { 7, 320 },
377                 CROPCAP(/* minhdelayx1 */ 68,
378                         /* hdelayx1 */ 130,
379                         /* swidth */ (640 * 910 + 780 / 2) / 780,
380                         /* totalwidth */ 910,
381                         /* sqwidth */ 780,
382                         /* vdelay */ 0x1a,
383                         /* sheight */ 576,
384                         /* videostart0 */ 23)
385         },{
386                 .v4l2_id        = V4L2_STD_PAL_M,
387                 .name           = "PAL-M",
388                 .Fsc            = 28636363,
389                 .swidth         = 640,
390                 .sheight        = 480,
391                 .totalwidth     = 910,
392                 .adelay         = 0x68,
393                 .bdelay         = 0x5d,
394                 .iform          = (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
395                 .scaledtwidth   = 780,
396                 .hdelayx1       = 135,
397                 .hactivex1      = 754,
398                 .vdelay         = 0x1a,
399                 .vbipack        = 144,
400                 .sram           = -1,
401                 .vbistart       = { 10, 273 },
402                 CROPCAP(/* minhdelayx1 */ 68,
403                         /* hdelayx1 */ 135,
404                         /* swidth */ (640 * 910 + 780 / 2) / 780,
405                         /* totalwidth */ 910,
406                         /* sqwidth */ 780,
407                         /* vdelay */ 0x1a,
408                         /* sheight */ 480,
409                         /* videostart0 */ 23)
410         },{
411                 .v4l2_id        = V4L2_STD_PAL_N,
412                 .name           = "PAL-N",
413                 .Fsc            = 35468950,
414                 .swidth         = 768,
415                 .sheight        = 576,
416                 .totalwidth     = 1135,
417                 .adelay         = 0x7f,
418                 .bdelay         = 0x72,
419                 .iform          = (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
420                 .scaledtwidth   = 944,
421                 .hdelayx1       = 186,
422                 .hactivex1      = 922,
423                 .vdelay         = 0x20,
424                 .vbipack        = 144,
425                 .sram           = -1,
426                 .vbistart       = { 7, 320 },
427                 CROPCAP(/* minhdelayx1 */ 68,
428                         /* hdelayx1 */ 186,
429                         /* swidth */ (768 * 1135 + 944 / 2) / 944,
430                         /* totalwidth */ 1135,
431                         /* sqwidth */ 944,
432                         /* vdelay */ 0x20,
433                         /* sheight */ 576,
434                         /* videostart0 */ 23)
435         },{
436                 .v4l2_id        = V4L2_STD_NTSC_M_JP,
437                 .name           = "NTSC-JP",
438                 .Fsc            = 28636363,
439                 .swidth         = 640,
440                 .sheight        = 480,
441                 .totalwidth     = 910,
442                 .adelay         = 0x68,
443                 .bdelay         = 0x5d,
444                 .iform          = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
445                 .scaledtwidth   = 780,
446                 .hdelayx1       = 135,
447                 .hactivex1      = 754,
448                 .vdelay         = 0x16,
449                 .vbipack        = 144,
450                 .sram           = -1,
451                 .vbistart       = { 10, 273 },
452                 CROPCAP(/* minhdelayx1 */ 68,
453                         /* hdelayx1 */ 135,
454                         /* swidth */ (640 * 910 + 780 / 2) / 780,
455                         /* totalwidth */ 910,
456                         /* sqwidth */ 780,
457                         /* vdelay */ 0x16,
458                         /* sheight */ 480,
459                         /* videostart0 */ 23)
460         },{
461                 /* that one hopefully works with the strange timing
462                  * which video recorders produce when playing a NTSC
463                  * tape on a PAL TV ... */
464                 .v4l2_id        = V4L2_STD_PAL_60,
465                 .name           = "PAL-60",
466                 .Fsc            = 35468950,
467                 .swidth         = 924,
468                 .sheight        = 480,
469                 .totalwidth     = 1135,
470                 .adelay         = 0x7f,
471                 .bdelay         = 0x72,
472                 .iform          = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
473                 .scaledtwidth   = 1135,
474                 .hdelayx1       = 186,
475                 .hactivex1      = 924,
476                 .vdelay         = 0x1a,
477                 .vbipack        = 255,
478                 .vtotal         = 524,
479                 .sram           = -1,
480                 .vbistart       = { 10, 273 },
481                 CROPCAP(/* minhdelayx1 */ 68,
482                         /* hdelayx1 */ 186,
483                         /* swidth */ 924,
484                         /* totalwidth */ 1135,
485                         /* sqwidth */ 944,
486                         /* vdelay */ 0x1a,
487                         /* sheight */ 480,
488                         /* videostart0 */ 23)
489         }
490 };
491 static const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
492
493 /* ----------------------------------------------------------------------- */
494 /* bttv format list
495    packed pixel formats must come first */
496 static const struct bttv_format formats[] = {
497         {
498                 .name     = "8 bpp, gray",
499                 .fourcc   = V4L2_PIX_FMT_GREY,
500                 .btformat = BT848_COLOR_FMT_Y8,
501                 .depth    = 8,
502                 .flags    = FORMAT_FLAGS_PACKED,
503         },{
504                 .name     = "8 bpp, dithered color",
505                 .fourcc   = V4L2_PIX_FMT_HI240,
506                 .btformat = BT848_COLOR_FMT_RGB8,
507                 .depth    = 8,
508                 .flags    = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
509         },{
510                 .name     = "15 bpp RGB, le",
511                 .fourcc   = V4L2_PIX_FMT_RGB555,
512                 .btformat = BT848_COLOR_FMT_RGB15,
513                 .depth    = 16,
514                 .flags    = FORMAT_FLAGS_PACKED,
515         },{
516                 .name     = "15 bpp RGB, be",
517                 .fourcc   = V4L2_PIX_FMT_RGB555X,
518                 .btformat = BT848_COLOR_FMT_RGB15,
519                 .btswap   = 0x03, /* byteswap */
520                 .depth    = 16,
521                 .flags    = FORMAT_FLAGS_PACKED,
522         },{
523                 .name     = "16 bpp RGB, le",
524                 .fourcc   = V4L2_PIX_FMT_RGB565,
525                 .btformat = BT848_COLOR_FMT_RGB16,
526                 .depth    = 16,
527                 .flags    = FORMAT_FLAGS_PACKED,
528         },{
529                 .name     = "16 bpp RGB, be",
530                 .fourcc   = V4L2_PIX_FMT_RGB565X,
531                 .btformat = BT848_COLOR_FMT_RGB16,
532                 .btswap   = 0x03, /* byteswap */
533                 .depth    = 16,
534                 .flags    = FORMAT_FLAGS_PACKED,
535         },{
536                 .name     = "24 bpp RGB, le",
537                 .fourcc   = V4L2_PIX_FMT_BGR24,
538                 .btformat = BT848_COLOR_FMT_RGB24,
539                 .depth    = 24,
540                 .flags    = FORMAT_FLAGS_PACKED,
541         },{
542                 .name     = "32 bpp RGB, le",
543                 .fourcc   = V4L2_PIX_FMT_BGR32,
544                 .btformat = BT848_COLOR_FMT_RGB32,
545                 .depth    = 32,
546                 .flags    = FORMAT_FLAGS_PACKED,
547         },{
548                 .name     = "32 bpp RGB, be",
549                 .fourcc   = V4L2_PIX_FMT_RGB32,
550                 .btformat = BT848_COLOR_FMT_RGB32,
551                 .btswap   = 0x0f, /* byte+word swap */
552                 .depth    = 32,
553                 .flags    = FORMAT_FLAGS_PACKED,
554         },{
555                 .name     = "4:2:2, packed, YUYV",
556                 .fourcc   = V4L2_PIX_FMT_YUYV,
557                 .btformat = BT848_COLOR_FMT_YUY2,
558                 .depth    = 16,
559                 .flags    = FORMAT_FLAGS_PACKED,
560         },{
561                 .name     = "4:2:2, packed, YUYV",
562                 .fourcc   = V4L2_PIX_FMT_YUYV,
563                 .btformat = BT848_COLOR_FMT_YUY2,
564                 .depth    = 16,
565                 .flags    = FORMAT_FLAGS_PACKED,
566         },{
567                 .name     = "4:2:2, packed, UYVY",
568                 .fourcc   = V4L2_PIX_FMT_UYVY,
569                 .btformat = BT848_COLOR_FMT_YUY2,
570                 .btswap   = 0x03, /* byteswap */
571                 .depth    = 16,
572                 .flags    = FORMAT_FLAGS_PACKED,
573         },{
574                 .name     = "4:2:2, planar, Y-Cb-Cr",
575                 .fourcc   = V4L2_PIX_FMT_YUV422P,
576                 .btformat = BT848_COLOR_FMT_YCrCb422,
577                 .depth    = 16,
578                 .flags    = FORMAT_FLAGS_PLANAR,
579                 .hshift   = 1,
580                 .vshift   = 0,
581         },{
582                 .name     = "4:2:0, planar, Y-Cb-Cr",
583                 .fourcc   = V4L2_PIX_FMT_YUV420,
584                 .btformat = BT848_COLOR_FMT_YCrCb422,
585                 .depth    = 12,
586                 .flags    = FORMAT_FLAGS_PLANAR,
587                 .hshift   = 1,
588                 .vshift   = 1,
589         },{
590                 .name     = "4:2:0, planar, Y-Cr-Cb",
591                 .fourcc   = V4L2_PIX_FMT_YVU420,
592                 .btformat = BT848_COLOR_FMT_YCrCb422,
593                 .depth    = 12,
594                 .flags    = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
595                 .hshift   = 1,
596                 .vshift   = 1,
597         },{
598                 .name     = "4:1:1, planar, Y-Cb-Cr",
599                 .fourcc   = V4L2_PIX_FMT_YUV411P,
600                 .btformat = BT848_COLOR_FMT_YCrCb411,
601                 .depth    = 12,
602                 .flags    = FORMAT_FLAGS_PLANAR,
603                 .hshift   = 2,
604                 .vshift   = 0,
605         },{
606                 .name     = "4:1:0, planar, Y-Cb-Cr",
607                 .fourcc   = V4L2_PIX_FMT_YUV410,
608                 .btformat = BT848_COLOR_FMT_YCrCb411,
609                 .depth    = 9,
610                 .flags    = FORMAT_FLAGS_PLANAR,
611                 .hshift   = 2,
612                 .vshift   = 2,
613         },{
614                 .name     = "4:1:0, planar, Y-Cr-Cb",
615                 .fourcc   = V4L2_PIX_FMT_YVU410,
616                 .btformat = BT848_COLOR_FMT_YCrCb411,
617                 .depth    = 9,
618                 .flags    = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
619                 .hshift   = 2,
620                 .vshift   = 2,
621         },{
622                 .name     = "raw scanlines",
623                 .fourcc   = -1,
624                 .btformat = BT848_COLOR_FMT_RAW,
625                 .depth    = 8,
626                 .flags    = FORMAT_FLAGS_RAW,
627         }
628 };
629 static const unsigned int FORMATS = ARRAY_SIZE(formats);
630
631 /* ----------------------------------------------------------------------- */
632
633 #define V4L2_CID_PRIVATE_CHROMA_AGC  (V4L2_CID_PRIVATE_BASE + 0)
634 #define V4L2_CID_PRIVATE_COMBFILTER  (V4L2_CID_PRIVATE_BASE + 1)
635 #define V4L2_CID_PRIVATE_AUTOMUTE    (V4L2_CID_PRIVATE_BASE + 2)
636 #define V4L2_CID_PRIVATE_LUMAFILTER  (V4L2_CID_PRIVATE_BASE + 3)
637 #define V4L2_CID_PRIVATE_AGC_CRUSH   (V4L2_CID_PRIVATE_BASE + 4)
638 #define V4L2_CID_PRIVATE_VCR_HACK    (V4L2_CID_PRIVATE_BASE + 5)
639 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER   (V4L2_CID_PRIVATE_BASE + 6)
640 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER   (V4L2_CID_PRIVATE_BASE + 7)
641 #define V4L2_CID_PRIVATE_UV_RATIO    (V4L2_CID_PRIVATE_BASE + 8)
642 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE    (V4L2_CID_PRIVATE_BASE + 9)
643 #define V4L2_CID_PRIVATE_CORING      (V4L2_CID_PRIVATE_BASE + 10)
644 #define V4L2_CID_PRIVATE_LASTP1      (V4L2_CID_PRIVATE_BASE + 11)
645
646 static const struct v4l2_queryctrl no_ctl = {
647         .name  = "42",
648         .flags = V4L2_CTRL_FLAG_DISABLED,
649 };
650 static const struct v4l2_queryctrl bttv_ctls[] = {
651         /* --- video --- */
652         {
653                 .id            = V4L2_CID_BRIGHTNESS,
654                 .name          = "Brightness",
655                 .minimum       = 0,
656                 .maximum       = 65535,
657                 .step          = 256,
658                 .default_value = 32768,
659                 .type          = V4L2_CTRL_TYPE_INTEGER,
660         },{
661                 .id            = V4L2_CID_CONTRAST,
662                 .name          = "Contrast",
663                 .minimum       = 0,
664                 .maximum       = 65535,
665                 .step          = 128,
666                 .default_value = 32768,
667                 .type          = V4L2_CTRL_TYPE_INTEGER,
668         },{
669                 .id            = V4L2_CID_SATURATION,
670                 .name          = "Saturation",
671                 .minimum       = 0,
672                 .maximum       = 65535,
673                 .step          = 128,
674                 .default_value = 32768,
675                 .type          = V4L2_CTRL_TYPE_INTEGER,
676         },{
677                 .id            = V4L2_CID_HUE,
678                 .name          = "Hue",
679                 .minimum       = 0,
680                 .maximum       = 65535,
681                 .step          = 256,
682                 .default_value = 32768,
683                 .type          = V4L2_CTRL_TYPE_INTEGER,
684         },
685         /* --- audio --- */
686         {
687                 .id            = V4L2_CID_AUDIO_MUTE,
688                 .name          = "Mute",
689                 .minimum       = 0,
690                 .maximum       = 1,
691                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
692         },{
693                 .id            = V4L2_CID_AUDIO_VOLUME,
694                 .name          = "Volume",
695                 .minimum       = 0,
696                 .maximum       = 65535,
697                 .step          = 65535/100,
698                 .default_value = 65535,
699                 .type          = V4L2_CTRL_TYPE_INTEGER,
700         },{
701                 .id            = V4L2_CID_AUDIO_BALANCE,
702                 .name          = "Balance",
703                 .minimum       = 0,
704                 .maximum       = 65535,
705                 .step          = 65535/100,
706                 .default_value = 32768,
707                 .type          = V4L2_CTRL_TYPE_INTEGER,
708         },{
709                 .id            = V4L2_CID_AUDIO_BASS,
710                 .name          = "Bass",
711                 .minimum       = 0,
712                 .maximum       = 65535,
713                 .step          = 65535/100,
714                 .default_value = 32768,
715                 .type          = V4L2_CTRL_TYPE_INTEGER,
716         },{
717                 .id            = V4L2_CID_AUDIO_TREBLE,
718                 .name          = "Treble",
719                 .minimum       = 0,
720                 .maximum       = 65535,
721                 .step          = 65535/100,
722                 .default_value = 32768,
723                 .type          = V4L2_CTRL_TYPE_INTEGER,
724         },
725         /* --- private --- */
726         {
727                 .id            = V4L2_CID_PRIVATE_CHROMA_AGC,
728                 .name          = "chroma agc",
729                 .minimum       = 0,
730                 .maximum       = 1,
731                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
732         },{
733                 .id            = V4L2_CID_PRIVATE_COMBFILTER,
734                 .name          = "combfilter",
735                 .minimum       = 0,
736                 .maximum       = 1,
737                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
738         },{
739                 .id            = V4L2_CID_PRIVATE_AUTOMUTE,
740                 .name          = "automute",
741                 .minimum       = 0,
742                 .maximum       = 1,
743                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
744         },{
745                 .id            = V4L2_CID_PRIVATE_LUMAFILTER,
746                 .name          = "luma decimation filter",
747                 .minimum       = 0,
748                 .maximum       = 1,
749                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
750         },{
751                 .id            = V4L2_CID_PRIVATE_AGC_CRUSH,
752                 .name          = "agc crush",
753                 .minimum       = 0,
754                 .maximum       = 1,
755                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
756         },{
757                 .id            = V4L2_CID_PRIVATE_VCR_HACK,
758                 .name          = "vcr hack",
759                 .minimum       = 0,
760                 .maximum       = 1,
761                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
762         },{
763                 .id            = V4L2_CID_PRIVATE_WHITECRUSH_UPPER,
764                 .name          = "whitecrush upper",
765                 .minimum       = 0,
766                 .maximum       = 255,
767                 .step          = 1,
768                 .default_value = 0xCF,
769                 .type          = V4L2_CTRL_TYPE_INTEGER,
770         },{
771                 .id            = V4L2_CID_PRIVATE_WHITECRUSH_LOWER,
772                 .name          = "whitecrush lower",
773                 .minimum       = 0,
774                 .maximum       = 255,
775                 .step          = 1,
776                 .default_value = 0x7F,
777                 .type          = V4L2_CTRL_TYPE_INTEGER,
778         },{
779                 .id            = V4L2_CID_PRIVATE_UV_RATIO,
780                 .name          = "uv ratio",
781                 .minimum       = 0,
782                 .maximum       = 100,
783                 .step          = 1,
784                 .default_value = 50,
785                 .type          = V4L2_CTRL_TYPE_INTEGER,
786         },{
787                 .id            = V4L2_CID_PRIVATE_FULL_LUMA_RANGE,
788                 .name          = "full luma range",
789                 .minimum       = 0,
790                 .maximum       = 1,
791                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
792         },{
793                 .id            = V4L2_CID_PRIVATE_CORING,
794                 .name          = "coring",
795                 .minimum       = 0,
796                 .maximum       = 3,
797                 .step          = 1,
798                 .default_value = 0,
799                 .type          = V4L2_CTRL_TYPE_INTEGER,
800         }
801
802
803
804 };
805
806 static const struct v4l2_queryctrl *ctrl_by_id(int id)
807 {
808         int i;
809
810         for (i = 0; i < ARRAY_SIZE(bttv_ctls); i++)
811                 if (bttv_ctls[i].id == id)
812                         return bttv_ctls+i;
813
814         return NULL;
815 }
816
817 /* ----------------------------------------------------------------------- */
818 /* resource management                                                     */
819
820 /*
821    RESOURCE_    allocated by                freed by
822
823    VIDEO_READ   bttv_read 1)                bttv_read 2)
824
825    VIDEO_STREAM VIDIOC_STREAMON             VIDIOC_STREAMOFF
826                  VIDIOC_QBUF 1)              bttv_release
827                  VIDIOCMCAPTURE 1)
828
829    OVERLAY       VIDIOCCAPTURE on            VIDIOCCAPTURE off
830                  VIDIOC_OVERLAY on           VIDIOC_OVERLAY off
831                  3)                          bttv_release
832
833    VBI           VIDIOC_STREAMON             VIDIOC_STREAMOFF
834                  VIDIOC_QBUF 1)              bttv_release
835                  bttv_read, bttv_poll 1) 4)
836
837    1) The resource must be allocated when we enter buffer prepare functions
838       and remain allocated while buffers are in the DMA queue.
839    2) This is a single frame read.
840    3) VIDIOC_S_FBUF and VIDIOC_S_FMT (OVERLAY) still work when
841       RESOURCE_OVERLAY is allocated.
842    4) This is a continuous read, implies VIDIOC_STREAMON.
843
844    Note this driver permits video input and standard changes regardless if
845    resources are allocated.
846 */
847
848 #define VBI_RESOURCES (RESOURCE_VBI)
849 #define VIDEO_RESOURCES (RESOURCE_VIDEO_READ | \
850                          RESOURCE_VIDEO_STREAM | \
851                          RESOURCE_OVERLAY)
852
853 static
854 int check_alloc_btres_lock(struct bttv *btv, struct bttv_fh *fh, int bit)
855 {
856         int xbits; /* mutual exclusive resources */
857
858         if (fh->resources & bit)
859                 /* have it already allocated */
860                 return 1;
861
862         xbits = bit;
863         if (bit & (RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM))
864                 xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM;
865
866         /* is it free? */
867         if (btv->resources & xbits) {
868                 /* no, someone else uses it */
869                 goto fail;
870         }
871
872         if ((bit & VIDEO_RESOURCES)
873             && 0 == (btv->resources & VIDEO_RESOURCES)) {
874                 /* Do crop - use current, don't - use default parameters. */
875                 __s32 top = btv->crop[!!fh->do_crop].rect.top;
876
877                 if (btv->vbi_end > top)
878                         goto fail;
879
880                 /* We cannot capture the same line as video and VBI data.
881                    Claim scan lines crop[].rect.top to bottom. */
882                 btv->crop_start = top;
883         } else if (bit & VBI_RESOURCES) {
884                 __s32 end = fh->vbi_fmt.end;
885
886                 if (end > btv->crop_start)
887                         goto fail;
888
889                 /* Claim scan lines above fh->vbi_fmt.end. */
890                 btv->vbi_end = end;
891         }
892
893         /* it's free, grab it */
894         fh->resources  |= bit;
895         btv->resources |= bit;
896         return 1;
897
898  fail:
899         return 0;
900 }
901
902 static
903 int check_btres(struct bttv_fh *fh, int bit)
904 {
905         return (fh->resources & bit);
906 }
907
908 static
909 int locked_btres(struct bttv *btv, int bit)
910 {
911         return (btv->resources & bit);
912 }
913
914 /* Call with btv->lock down. */
915 static void
916 disclaim_vbi_lines(struct bttv *btv)
917 {
918         btv->vbi_end = 0;
919 }
920
921 /* Call with btv->lock down. */
922 static void
923 disclaim_video_lines(struct bttv *btv)
924 {
925         const struct bttv_tvnorm *tvnorm;
926         u8 crop;
927
928         tvnorm = &bttv_tvnorms[btv->tvnorm];
929         btv->crop_start = tvnorm->cropcap.bounds.top
930                 + tvnorm->cropcap.bounds.height;
931
932         /* VBI capturing ends at VDELAY, start of video capturing, no
933            matter how many lines the VBI RISC program expects. When video
934            capturing is off, it shall no longer "preempt" VBI capturing,
935            so we set VDELAY to maximum. */
936         crop = btread(BT848_E_CROP) | 0xc0;
937         btwrite(crop, BT848_E_CROP);
938         btwrite(0xfe, BT848_E_VDELAY_LO);
939         btwrite(crop, BT848_O_CROP);
940         btwrite(0xfe, BT848_O_VDELAY_LO);
941 }
942
943 static
944 void free_btres_lock(struct bttv *btv, struct bttv_fh *fh, int bits)
945 {
946         if ((fh->resources & bits) != bits) {
947                 /* trying to free resources not allocated by us ... */
948                 pr_err("BUG! (btres)\n");
949         }
950         fh->resources  &= ~bits;
951         btv->resources &= ~bits;
952
953         bits = btv->resources;
954
955         if (0 == (bits & VIDEO_RESOURCES))
956                 disclaim_video_lines(btv);
957
958         if (0 == (bits & VBI_RESOURCES))
959                 disclaim_vbi_lines(btv);
960 }
961
962 /* ----------------------------------------------------------------------- */
963 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC          */
964
965 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
966    PLL_X = Reference pre-divider (0=1, 1=2)
967    PLL_C = Post divider (0=6, 1=4)
968    PLL_I = Integer input
969    PLL_F = Fractional input
970
971    F_input = 28.636363 MHz:
972    PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
973 */
974
975 static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
976 {
977         unsigned char fl, fh, fi;
978
979         /* prevent overflows */
980         fin/=4;
981         fout/=4;
982
983         fout*=12;
984         fi=fout/fin;
985
986         fout=(fout%fin)*256;
987         fh=fout/fin;
988
989         fout=(fout%fin)*256;
990         fl=fout/fin;
991
992         btwrite(fl, BT848_PLL_F_LO);
993         btwrite(fh, BT848_PLL_F_HI);
994         btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
995 }
996
997 static void set_pll(struct bttv *btv)
998 {
999         int i;
1000
1001         if (!btv->pll.pll_crystal)
1002                 return;
1003
1004         if (btv->pll.pll_ofreq == btv->pll.pll_current) {
1005                 dprintk("%d: PLL: no change required\n", btv->c.nr);
1006                 return;
1007         }
1008
1009         if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
1010                 /* no PLL needed */
1011                 if (btv->pll.pll_current == 0)
1012                         return;
1013                 if (bttv_verbose)
1014                         pr_info("%d: PLL can sleep, using XTAL (%d)\n",
1015                                 btv->c.nr, btv->pll.pll_ifreq);
1016                 btwrite(0x00,BT848_TGCTRL);
1017                 btwrite(0x00,BT848_PLL_XCI);
1018                 btv->pll.pll_current = 0;
1019                 return;
1020         }
1021
1022         if (bttv_verbose)
1023                 pr_info("%d: Setting PLL: %d => %d (needs up to 100ms)\n",
1024                         btv->c.nr,
1025                         btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1026         set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1027
1028         for (i=0; i<10; i++) {
1029                 /*  Let other people run while the PLL stabilizes */
1030                 msleep(10);
1031
1032                 if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
1033                         btwrite(0,BT848_DSTATUS);
1034                 } else {
1035                         btwrite(0x08,BT848_TGCTRL);
1036                         btv->pll.pll_current = btv->pll.pll_ofreq;
1037                         if (bttv_verbose)
1038                                 pr_info("PLL set ok\n");
1039                         return;
1040                 }
1041         }
1042         btv->pll.pll_current = -1;
1043         if (bttv_verbose)
1044                 pr_info("Setting PLL failed\n");
1045         return;
1046 }
1047
1048 /* used to switch between the bt848's analog/digital video capture modes */
1049 static void bt848A_set_timing(struct bttv *btv)
1050 {
1051         int i, len;
1052         int table_idx = bttv_tvnorms[btv->tvnorm].sram;
1053         int fsc       = bttv_tvnorms[btv->tvnorm].Fsc;
1054
1055         if (btv->input == btv->dig) {
1056                 dprintk("%d: load digital timing table (table_idx=%d)\n",
1057                         btv->c.nr,table_idx);
1058
1059                 /* timing change...reset timing generator address */
1060                 btwrite(0x00, BT848_TGCTRL);
1061                 btwrite(0x02, BT848_TGCTRL);
1062                 btwrite(0x00, BT848_TGCTRL);
1063
1064                 len=SRAM_Table[table_idx][0];
1065                 for(i = 1; i <= len; i++)
1066                         btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
1067                 btv->pll.pll_ofreq = 27000000;
1068
1069                 set_pll(btv);
1070                 btwrite(0x11, BT848_TGCTRL);
1071                 btwrite(0x41, BT848_DVSIF);
1072         } else {
1073                 btv->pll.pll_ofreq = fsc;
1074                 set_pll(btv);
1075                 btwrite(0x0, BT848_DVSIF);
1076         }
1077 }
1078
1079 /* ----------------------------------------------------------------------- */
1080
1081 static void bt848_bright(struct bttv *btv, int bright)
1082 {
1083         int value;
1084
1085         // printk("set bright: %d\n", bright); // DEBUG
1086         btv->bright = bright;
1087
1088         /* We want -128 to 127 we get 0-65535 */
1089         value = (bright >> 8) - 128;
1090         btwrite(value & 0xff, BT848_BRIGHT);
1091 }
1092
1093 static void bt848_hue(struct bttv *btv, int hue)
1094 {
1095         int value;
1096
1097         btv->hue = hue;
1098
1099         /* -128 to 127 */
1100         value = (hue >> 8) - 128;
1101         btwrite(value & 0xff, BT848_HUE);
1102 }
1103
1104 static void bt848_contrast(struct bttv *btv, int cont)
1105 {
1106         int value,hibit;
1107
1108         btv->contrast = cont;
1109
1110         /* 0-511 */
1111         value = (cont  >> 7);
1112         hibit = (value >> 6) & 4;
1113         btwrite(value & 0xff, BT848_CONTRAST_LO);
1114         btaor(hibit, ~4, BT848_E_CONTROL);
1115         btaor(hibit, ~4, BT848_O_CONTROL);
1116 }
1117
1118 static void bt848_sat(struct bttv *btv, int color)
1119 {
1120         int val_u,val_v,hibits;
1121
1122         btv->saturation = color;
1123
1124         /* 0-511 for the color */
1125         val_u   = ((color * btv->opt_uv_ratio) / 50) >> 7;
1126         val_v   = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
1127         hibits  = (val_u >> 7) & 2;
1128         hibits |= (val_v >> 8) & 1;
1129         btwrite(val_u & 0xff, BT848_SAT_U_LO);
1130         btwrite(val_v & 0xff, BT848_SAT_V_LO);
1131         btaor(hibits, ~3, BT848_E_CONTROL);
1132         btaor(hibits, ~3, BT848_O_CONTROL);
1133 }
1134
1135 /* ----------------------------------------------------------------------- */
1136
1137 static int
1138 video_mux(struct bttv *btv, unsigned int input)
1139 {
1140         int mux,mask2;
1141
1142         if (input >= bttv_tvcards[btv->c.type].video_inputs)
1143                 return -EINVAL;
1144
1145         /* needed by RemoteVideo MX */
1146         mask2 = bttv_tvcards[btv->c.type].gpiomask2;
1147         if (mask2)
1148                 gpio_inout(mask2,mask2);
1149
1150         if (input == btv->svhs)  {
1151                 btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
1152                 btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
1153         } else {
1154                 btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
1155                 btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
1156         }
1157         mux = bttv_muxsel(btv, input);
1158         btaor(mux<<5, ~(3<<5), BT848_IFORM);
1159         dprintk("%d: video mux: input=%d mux=%d\n", btv->c.nr, input, mux);
1160
1161         /* card specific hook */
1162         if(bttv_tvcards[btv->c.type].muxsel_hook)
1163                 bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
1164         return 0;
1165 }
1166
1167 static char *audio_modes[] = {
1168         "audio: tuner", "audio: radio", "audio: extern",
1169         "audio: intern", "audio: mute"
1170 };
1171
1172 static int
1173 audio_mux(struct bttv *btv, int input, int mute)
1174 {
1175         int gpio_val, signal;
1176         struct v4l2_control ctrl;
1177
1178         gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
1179                    bttv_tvcards[btv->c.type].gpiomask);
1180         signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
1181
1182         btv->mute = mute;
1183         btv->audio = input;
1184
1185         /* automute */
1186         mute = mute || (btv->opt_automute && !signal && !btv->radio_user);
1187
1188         if (mute)
1189                 gpio_val = bttv_tvcards[btv->c.type].gpiomute;
1190         else
1191                 gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
1192
1193         switch (btv->c.type) {
1194         case BTTV_BOARD_VOODOOTV_FM:
1195         case BTTV_BOARD_VOODOOTV_200:
1196                 gpio_val = bttv_tda9880_setnorm(btv, gpio_val);
1197                 break;
1198
1199         default:
1200                 gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
1201         }
1202
1203         if (bttv_gpio)
1204                 bttv_gpio_tracking(btv, audio_modes[mute ? 4 : input]);
1205         if (in_interrupt())
1206                 return 0;
1207
1208         ctrl.id = V4L2_CID_AUDIO_MUTE;
1209         ctrl.value = btv->mute;
1210         bttv_call_all(btv, core, s_ctrl, &ctrl);
1211         if (btv->sd_msp34xx) {
1212                 u32 in;
1213
1214                 /* Note: the inputs tuner/radio/extern/intern are translated
1215                    to msp routings. This assumes common behavior for all msp3400
1216                    based TV cards. When this assumption fails, then the
1217                    specific MSP routing must be added to the card table.
1218                    For now this is sufficient. */
1219                 switch (input) {
1220                 case TVAUDIO_INPUT_RADIO:
1221                         in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1222                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1223                         break;
1224                 case TVAUDIO_INPUT_EXTERN:
1225                         in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
1226                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1227                         break;
1228                 case TVAUDIO_INPUT_INTERN:
1229                         /* Yes, this is the same input as for RADIO. I doubt
1230                            if this is ever used. The only board with an INTERN
1231                            input is the BTTV_BOARD_AVERMEDIA98. I wonder how
1232                            that was tested. My guess is that the whole INTERN
1233                            input does not work. */
1234                         in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1235                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1236                         break;
1237                 case TVAUDIO_INPUT_TUNER:
1238                 default:
1239                         /* This is the only card that uses TUNER2, and afaik,
1240                            is the only difference between the VOODOOTV_FM
1241                            and VOODOOTV_200 */
1242                         if (btv->c.type == BTTV_BOARD_VOODOOTV_200)
1243                                 in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \
1244                                         MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER);
1245                         else
1246                                 in = MSP_INPUT_DEFAULT;
1247                         break;
1248                 }
1249                 v4l2_subdev_call(btv->sd_msp34xx, audio, s_routing,
1250                                in, MSP_OUTPUT_DEFAULT, 0);
1251         }
1252         if (btv->sd_tvaudio) {
1253                 v4l2_subdev_call(btv->sd_tvaudio, audio, s_routing,
1254                                 input, 0, 0);
1255         }
1256         return 0;
1257 }
1258
1259 static inline int
1260 audio_mute(struct bttv *btv, int mute)
1261 {
1262         return audio_mux(btv, btv->audio, mute);
1263 }
1264
1265 static inline int
1266 audio_input(struct bttv *btv, int input)
1267 {
1268         return audio_mux(btv, input, btv->mute);
1269 }
1270
1271 static void
1272 bttv_crop_calc_limits(struct bttv_crop *c)
1273 {
1274         /* Scale factor min. 1:1, max. 16:1. Min. image size
1275            48 x 32. Scaled width must be a multiple of 4. */
1276
1277         if (1) {
1278                 /* For bug compatibility with VIDIOCGCAP and image
1279                    size checks in earlier driver versions. */
1280                 c->min_scaled_width = 48;
1281                 c->min_scaled_height = 32;
1282         } else {
1283                 c->min_scaled_width =
1284                         (max(48, c->rect.width >> 4) + 3) & ~3;
1285                 c->min_scaled_height =
1286                         max(32, c->rect.height >> 4);
1287         }
1288
1289         c->max_scaled_width  = c->rect.width & ~3;
1290         c->max_scaled_height = c->rect.height;
1291 }
1292
1293 static void
1294 bttv_crop_reset(struct bttv_crop *c, unsigned int norm)
1295 {
1296         c->rect = bttv_tvnorms[norm].cropcap.defrect;
1297         bttv_crop_calc_limits(c);
1298 }
1299
1300 /* Call with btv->lock down. */
1301 static int
1302 set_tvnorm(struct bttv *btv, unsigned int norm)
1303 {
1304         const struct bttv_tvnorm *tvnorm;
1305         v4l2_std_id id;
1306
1307         BUG_ON(norm >= BTTV_TVNORMS);
1308         BUG_ON(btv->tvnorm >= BTTV_TVNORMS);
1309
1310         tvnorm = &bttv_tvnorms[norm];
1311
1312         if (memcmp(&bttv_tvnorms[btv->tvnorm].cropcap, &tvnorm->cropcap,
1313                     sizeof (tvnorm->cropcap))) {
1314                 bttv_crop_reset(&btv->crop[0], norm);
1315                 btv->crop[1] = btv->crop[0]; /* current = default */
1316
1317                 if (0 == (btv->resources & VIDEO_RESOURCES)) {
1318                         btv->crop_start = tvnorm->cropcap.bounds.top
1319                                 + tvnorm->cropcap.bounds.height;
1320                 }
1321         }
1322
1323         btv->tvnorm = norm;
1324
1325         btwrite(tvnorm->adelay, BT848_ADELAY);
1326         btwrite(tvnorm->bdelay, BT848_BDELAY);
1327         btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1328               BT848_IFORM);
1329         btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1330         btwrite(1, BT848_VBI_PACK_DEL);
1331         bt848A_set_timing(btv);
1332
1333         switch (btv->c.type) {
1334         case BTTV_BOARD_VOODOOTV_FM:
1335         case BTTV_BOARD_VOODOOTV_200:
1336                 bttv_tda9880_setnorm(btv, gpio_read());
1337                 break;
1338         }
1339         id = tvnorm->v4l2_id;
1340         bttv_call_all(btv, core, s_std, id);
1341
1342         return 0;
1343 }
1344
1345 /* Call with btv->lock down. */
1346 static void
1347 set_input(struct bttv *btv, unsigned int input, unsigned int norm)
1348 {
1349         unsigned long flags;
1350
1351         btv->input = input;
1352         if (irq_iswitch) {
1353                 spin_lock_irqsave(&btv->s_lock,flags);
1354                 if (btv->curr.frame_irq) {
1355                         /* active capture -> delayed input switch */
1356                         btv->new_input = input;
1357                 } else {
1358                         video_mux(btv,input);
1359                 }
1360                 spin_unlock_irqrestore(&btv->s_lock,flags);
1361         } else {
1362                 video_mux(btv,input);
1363         }
1364         audio_input(btv, (btv->tuner_type != TUNER_ABSENT && input == 0) ?
1365                          TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN);
1366         set_tvnorm(btv, norm);
1367 }
1368
1369 static void init_irqreg(struct bttv *btv)
1370 {
1371         /* clear status */
1372         btwrite(0xfffffUL, BT848_INT_STAT);
1373
1374         if (bttv_tvcards[btv->c.type].no_video) {
1375                 /* i2c only */
1376                 btwrite(BT848_INT_I2CDONE,
1377                         BT848_INT_MASK);
1378         } else {
1379                 /* full video */
1380                 btwrite((btv->triton1)  |
1381                         (btv->gpioirq ? BT848_INT_GPINT : 0) |
1382                         BT848_INT_SCERR |
1383                         (fdsr ? BT848_INT_FDSR : 0) |
1384                         BT848_INT_RISCI | BT848_INT_OCERR |
1385                         BT848_INT_FMTCHG|BT848_INT_HLOCK|
1386                         BT848_INT_I2CDONE,
1387                         BT848_INT_MASK);
1388         }
1389 }
1390
1391 static void init_bt848(struct bttv *btv)
1392 {
1393         int val;
1394
1395         if (bttv_tvcards[btv->c.type].no_video) {
1396                 /* very basic init only */
1397                 init_irqreg(btv);
1398                 return;
1399         }
1400
1401         btwrite(0x00, BT848_CAP_CTL);
1402         btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1403         btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1404
1405         /* set planar and packed mode trigger points and         */
1406         /* set rising edge of inverted GPINTR pin as irq trigger */
1407         btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1408                 BT848_GPIO_DMA_CTL_PLTP1_16|
1409                 BT848_GPIO_DMA_CTL_PLTP23_16|
1410                 BT848_GPIO_DMA_CTL_GPINTC|
1411                 BT848_GPIO_DMA_CTL_GPINTI,
1412                 BT848_GPIO_DMA_CTL);
1413
1414         val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1415         btwrite(val, BT848_E_SCLOOP);
1416         btwrite(val, BT848_O_SCLOOP);
1417
1418         btwrite(0x20, BT848_E_VSCALE_HI);
1419         btwrite(0x20, BT848_O_VSCALE_HI);
1420         btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1421                 BT848_ADC);
1422
1423         btwrite(whitecrush_upper, BT848_WC_UP);
1424         btwrite(whitecrush_lower, BT848_WC_DOWN);
1425
1426         if (btv->opt_lumafilter) {
1427                 btwrite(0, BT848_E_CONTROL);
1428                 btwrite(0, BT848_O_CONTROL);
1429         } else {
1430                 btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1431                 btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1432         }
1433
1434         bt848_bright(btv,   btv->bright);
1435         bt848_hue(btv,      btv->hue);
1436         bt848_contrast(btv, btv->contrast);
1437         bt848_sat(btv,      btv->saturation);
1438
1439         /* interrupt */
1440         init_irqreg(btv);
1441 }
1442
1443 static void bttv_reinit_bt848(struct bttv *btv)
1444 {
1445         unsigned long flags;
1446
1447         if (bttv_verbose)
1448                 pr_info("%d: reset, reinitialize\n", btv->c.nr);
1449         spin_lock_irqsave(&btv->s_lock,flags);
1450         btv->errors=0;
1451         bttv_set_dma(btv,0);
1452         spin_unlock_irqrestore(&btv->s_lock,flags);
1453
1454         init_bt848(btv);
1455         btv->pll.pll_current = -1;
1456         set_input(btv, btv->input, btv->tvnorm);
1457 }
1458
1459 static int bttv_g_ctrl(struct file *file, void *priv,
1460                                         struct v4l2_control *c)
1461 {
1462         struct bttv_fh *fh = priv;
1463         struct bttv *btv = fh->btv;
1464
1465         switch (c->id) {
1466         case V4L2_CID_BRIGHTNESS:
1467                 c->value = btv->bright;
1468                 break;
1469         case V4L2_CID_HUE:
1470                 c->value = btv->hue;
1471                 break;
1472         case V4L2_CID_CONTRAST:
1473                 c->value = btv->contrast;
1474                 break;
1475         case V4L2_CID_SATURATION:
1476                 c->value = btv->saturation;
1477                 break;
1478
1479         case V4L2_CID_AUDIO_MUTE:
1480         case V4L2_CID_AUDIO_VOLUME:
1481         case V4L2_CID_AUDIO_BALANCE:
1482         case V4L2_CID_AUDIO_BASS:
1483         case V4L2_CID_AUDIO_TREBLE:
1484                 bttv_call_all(btv, core, g_ctrl, c);
1485                 break;
1486
1487         case V4L2_CID_PRIVATE_CHROMA_AGC:
1488                 c->value = btv->opt_chroma_agc;
1489                 break;
1490         case V4L2_CID_PRIVATE_COMBFILTER:
1491                 c->value = btv->opt_combfilter;
1492                 break;
1493         case V4L2_CID_PRIVATE_LUMAFILTER:
1494                 c->value = btv->opt_lumafilter;
1495                 break;
1496         case V4L2_CID_PRIVATE_AUTOMUTE:
1497                 c->value = btv->opt_automute;
1498                 break;
1499         case V4L2_CID_PRIVATE_AGC_CRUSH:
1500                 c->value = btv->opt_adc_crush;
1501                 break;
1502         case V4L2_CID_PRIVATE_VCR_HACK:
1503                 c->value = btv->opt_vcr_hack;
1504                 break;
1505         case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1506                 c->value = btv->opt_whitecrush_upper;
1507                 break;
1508         case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1509                 c->value = btv->opt_whitecrush_lower;
1510                 break;
1511         case V4L2_CID_PRIVATE_UV_RATIO:
1512                 c->value = btv->opt_uv_ratio;
1513                 break;
1514         case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1515                 c->value = btv->opt_full_luma_range;
1516                 break;
1517         case V4L2_CID_PRIVATE_CORING:
1518                 c->value = btv->opt_coring;
1519                 break;
1520         default:
1521                 return -EINVAL;
1522         }
1523         return 0;
1524 }
1525
1526 static int bttv_s_ctrl(struct file *file, void *f,
1527                                         struct v4l2_control *c)
1528 {
1529         int err;
1530         int val;
1531         struct bttv_fh *fh = f;
1532         struct bttv *btv = fh->btv;
1533
1534         err = v4l2_prio_check(&btv->prio, fh->prio);
1535         if (0 != err)
1536                 return err;
1537
1538         switch (c->id) {
1539         case V4L2_CID_BRIGHTNESS:
1540                 bt848_bright(btv, c->value);
1541                 break;
1542         case V4L2_CID_HUE:
1543                 bt848_hue(btv, c->value);
1544                 break;
1545         case V4L2_CID_CONTRAST:
1546                 bt848_contrast(btv, c->value);
1547                 break;
1548         case V4L2_CID_SATURATION:
1549                 bt848_sat(btv, c->value);
1550                 break;
1551         case V4L2_CID_AUDIO_MUTE:
1552                 audio_mute(btv, c->value);
1553                 /* fall through */
1554         case V4L2_CID_AUDIO_VOLUME:
1555                 if (btv->volume_gpio)
1556                         btv->volume_gpio(btv, c->value);
1557
1558                 bttv_call_all(btv, core, s_ctrl, c);
1559                 break;
1560         case V4L2_CID_AUDIO_BALANCE:
1561         case V4L2_CID_AUDIO_BASS:
1562         case V4L2_CID_AUDIO_TREBLE:
1563                 bttv_call_all(btv, core, s_ctrl, c);
1564                 break;
1565
1566         case V4L2_CID_PRIVATE_CHROMA_AGC:
1567                 btv->opt_chroma_agc = c->value;
1568                 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1569                 btwrite(val, BT848_E_SCLOOP);
1570                 btwrite(val, BT848_O_SCLOOP);
1571                 break;
1572         case V4L2_CID_PRIVATE_COMBFILTER:
1573                 btv->opt_combfilter = c->value;
1574                 break;
1575         case V4L2_CID_PRIVATE_LUMAFILTER:
1576                 btv->opt_lumafilter = c->value;
1577                 if (btv->opt_lumafilter) {
1578                         btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1579                         btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1580                 } else {
1581                         btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1582                         btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1583                 }
1584                 break;
1585         case V4L2_CID_PRIVATE_AUTOMUTE:
1586                 btv->opt_automute = c->value;
1587                 break;
1588         case V4L2_CID_PRIVATE_AGC_CRUSH:
1589                 btv->opt_adc_crush = c->value;
1590                 btwrite(BT848_ADC_RESERVED |
1591                                 (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1592                                 BT848_ADC);
1593                 break;
1594         case V4L2_CID_PRIVATE_VCR_HACK:
1595                 btv->opt_vcr_hack = c->value;
1596                 break;
1597         case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1598                 btv->opt_whitecrush_upper = c->value;
1599                 btwrite(c->value, BT848_WC_UP);
1600                 break;
1601         case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1602                 btv->opt_whitecrush_lower = c->value;
1603                 btwrite(c->value, BT848_WC_DOWN);
1604                 break;
1605         case V4L2_CID_PRIVATE_UV_RATIO:
1606                 btv->opt_uv_ratio = c->value;
1607                 bt848_sat(btv, btv->saturation);
1608                 break;
1609         case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1610                 btv->opt_full_luma_range = c->value;
1611                 btaor((c->value<<7), ~BT848_OFORM_RANGE, BT848_OFORM);
1612                 break;
1613         case V4L2_CID_PRIVATE_CORING:
1614                 btv->opt_coring = c->value;
1615                 btaor((c->value<<5), ~BT848_OFORM_CORE32, BT848_OFORM);
1616                 break;
1617         default:
1618                 return -EINVAL;
1619         }
1620         return 0;
1621 }
1622
1623 /* ----------------------------------------------------------------------- */
1624
1625 void bttv_gpio_tracking(struct bttv *btv, char *comment)
1626 {
1627         unsigned int outbits, data;
1628         outbits = btread(BT848_GPIO_OUT_EN);
1629         data    = btread(BT848_GPIO_DATA);
1630         pr_debug("%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1631                  btv->c.nr, outbits, data & outbits, data & ~outbits, comment);
1632 }
1633
1634 static void bttv_field_count(struct bttv *btv)
1635 {
1636         int need_count = 0;
1637
1638         if (btv->users)
1639                 need_count++;
1640
1641         if (need_count) {
1642                 /* start field counter */
1643                 btor(BT848_INT_VSYNC,BT848_INT_MASK);
1644         } else {
1645                 /* stop field counter */
1646                 btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1647                 btv->field_count = 0;
1648         }
1649 }
1650
1651 static const struct bttv_format*
1652 format_by_fourcc(int fourcc)
1653 {
1654         unsigned int i;
1655
1656         for (i = 0; i < FORMATS; i++) {
1657                 if (-1 == formats[i].fourcc)
1658                         continue;
1659                 if (formats[i].fourcc == fourcc)
1660                         return formats+i;
1661         }
1662         return NULL;
1663 }
1664
1665 /* ----------------------------------------------------------------------- */
1666 /* misc helpers                                                            */
1667
1668 static int
1669 bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1670                     struct bttv_buffer *new)
1671 {
1672         struct bttv_buffer *old;
1673         unsigned long flags;
1674         int retval = 0;
1675
1676         dprintk("switch_overlay: enter [new=%p]\n", new);
1677         if (new)
1678                 new->vb.state = VIDEOBUF_DONE;
1679         spin_lock_irqsave(&btv->s_lock,flags);
1680         old = btv->screen;
1681         btv->screen = new;
1682         btv->loop_irq |= 1;
1683         bttv_set_dma(btv, 0x03);
1684         spin_unlock_irqrestore(&btv->s_lock,flags);
1685         if (NULL != old) {
1686                 dprintk("switch_overlay: old=%p state is %d\n",
1687                         old, old->vb.state);
1688                 bttv_dma_free(&fh->cap,btv, old);
1689                 kfree(old);
1690         }
1691         if (NULL == new)
1692                 free_btres_lock(btv,fh,RESOURCE_OVERLAY);
1693         dprintk("switch_overlay: done\n");
1694         return retval;
1695 }
1696
1697 /* ----------------------------------------------------------------------- */
1698 /* video4linux (1) interface                                               */
1699
1700 static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1701                                struct bttv_buffer *buf,
1702                                const struct bttv_format *fmt,
1703                                unsigned int width, unsigned int height,
1704                                enum v4l2_field field)
1705 {
1706         struct bttv_fh *fh = q->priv_data;
1707         int redo_dma_risc = 0;
1708         struct bttv_crop c;
1709         int norm;
1710         int rc;
1711
1712         /* check settings */
1713         if (NULL == fmt)
1714                 return -EINVAL;
1715         if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1716                 width  = RAW_BPL;
1717                 height = RAW_LINES*2;
1718                 if (width*height > buf->vb.bsize)
1719                         return -EINVAL;
1720                 buf->vb.size = buf->vb.bsize;
1721
1722                 /* Make sure tvnorm and vbi_end remain consistent
1723                    until we're done. */
1724
1725                 norm = btv->tvnorm;
1726
1727                 /* In this mode capturing always starts at defrect.top
1728                    (default VDELAY), ignoring cropping parameters. */
1729                 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
1730                         return -EINVAL;
1731                 }
1732
1733                 c.rect = bttv_tvnorms[norm].cropcap.defrect;
1734         } else {
1735                 norm = btv->tvnorm;
1736                 c = btv->crop[!!fh->do_crop];
1737
1738                 if (width < c.min_scaled_width ||
1739                     width > c.max_scaled_width ||
1740                     height < c.min_scaled_height)
1741                         return -EINVAL;
1742
1743                 switch (field) {
1744                 case V4L2_FIELD_TOP:
1745                 case V4L2_FIELD_BOTTOM:
1746                 case V4L2_FIELD_ALTERNATE:
1747                         /* btv->crop counts frame lines. Max. scale
1748                            factor is 16:1 for frames, 8:1 for fields. */
1749                         if (height * 2 > c.max_scaled_height)
1750                                 return -EINVAL;
1751                         break;
1752
1753                 default:
1754                         if (height > c.max_scaled_height)
1755                                 return -EINVAL;
1756                         break;
1757                 }
1758
1759                 buf->vb.size = (width * height * fmt->depth) >> 3;
1760                 if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
1761                         return -EINVAL;
1762         }
1763
1764         /* alloc + fill struct bttv_buffer (if changed) */
1765         if (buf->vb.width != width || buf->vb.height != height ||
1766             buf->vb.field != field ||
1767             buf->tvnorm != norm || buf->fmt != fmt ||
1768             buf->crop.top != c.rect.top ||
1769             buf->crop.left != c.rect.left ||
1770             buf->crop.width != c.rect.width ||
1771             buf->crop.height != c.rect.height) {
1772                 buf->vb.width  = width;
1773                 buf->vb.height = height;
1774                 buf->vb.field  = field;
1775                 buf->tvnorm    = norm;
1776                 buf->fmt       = fmt;
1777                 buf->crop      = c.rect;
1778                 redo_dma_risc = 1;
1779         }
1780
1781         /* alloc risc memory */
1782         if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1783                 redo_dma_risc = 1;
1784                 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
1785                         goto fail;
1786         }
1787
1788         if (redo_dma_risc)
1789                 if (0 != (rc = bttv_buffer_risc(btv,buf)))
1790                         goto fail;
1791
1792         buf->vb.state = VIDEOBUF_PREPARED;
1793         return 0;
1794
1795  fail:
1796         bttv_dma_free(q,btv,buf);
1797         return rc;
1798 }
1799
1800 static int
1801 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1802 {
1803         struct bttv_fh *fh = q->priv_data;
1804
1805         *size = fh->fmt->depth*fh->width*fh->height >> 3;
1806         if (0 == *count)
1807                 *count = gbuffers;
1808         if (*size * *count > gbuffers * gbufsize)
1809                 *count = (gbuffers * gbufsize) / *size;
1810         return 0;
1811 }
1812
1813 static int
1814 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1815                enum v4l2_field field)
1816 {
1817         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1818         struct bttv_fh *fh = q->priv_data;
1819
1820         return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
1821                                    fh->width, fh->height, field);
1822 }
1823
1824 static void
1825 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1826 {
1827         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1828         struct bttv_fh *fh = q->priv_data;
1829         struct bttv    *btv = fh->btv;
1830
1831         buf->vb.state = VIDEOBUF_QUEUED;
1832         list_add_tail(&buf->vb.queue,&btv->capture);
1833         if (!btv->curr.frame_irq) {
1834                 btv->loop_irq |= 1;
1835                 bttv_set_dma(btv, 0x03);
1836         }
1837 }
1838
1839 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1840 {
1841         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1842         struct bttv_fh *fh = q->priv_data;
1843
1844         bttv_dma_free(q,fh->btv,buf);
1845 }
1846
1847 static struct videobuf_queue_ops bttv_video_qops = {
1848         .buf_setup    = buffer_setup,
1849         .buf_prepare  = buffer_prepare,
1850         .buf_queue    = buffer_queue,
1851         .buf_release  = buffer_release,
1852 };
1853
1854 static int bttv_s_std(struct file *file, void *priv, v4l2_std_id *id)
1855 {
1856         struct bttv_fh *fh  = priv;
1857         struct bttv *btv = fh->btv;
1858         unsigned int i;
1859         int err;
1860
1861         err = v4l2_prio_check(&btv->prio, fh->prio);
1862         if (err)
1863                 goto err;
1864
1865         for (i = 0; i < BTTV_TVNORMS; i++)
1866                 if (*id & bttv_tvnorms[i].v4l2_id)
1867                         break;
1868         if (i == BTTV_TVNORMS) {
1869                 err = -EINVAL;
1870                 goto err;
1871         }
1872
1873         set_tvnorm(btv, i);
1874
1875 err:
1876
1877         return err;
1878 }
1879
1880 static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id)
1881 {
1882         struct bttv_fh *fh = f;
1883         struct bttv *btv = fh->btv;
1884
1885         if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1886                 *id = V4L2_STD_625_50;
1887         else
1888                 *id = V4L2_STD_525_60;
1889         return 0;
1890 }
1891
1892 static int bttv_enum_input(struct file *file, void *priv,
1893                                         struct v4l2_input *i)
1894 {
1895         struct bttv_fh *fh = priv;
1896         struct bttv *btv = fh->btv;
1897         int rc = 0;
1898
1899         if (i->index >= bttv_tvcards[btv->c.type].video_inputs) {
1900                 rc = -EINVAL;
1901                 goto err;
1902         }
1903
1904         i->type     = V4L2_INPUT_TYPE_CAMERA;
1905         i->audioset = 1;
1906
1907         if (btv->tuner_type != TUNER_ABSENT && i->index == 0) {
1908                 sprintf(i->name, "Television");
1909                 i->type  = V4L2_INPUT_TYPE_TUNER;
1910                 i->tuner = 0;
1911         } else if (i->index == btv->svhs) {
1912                 sprintf(i->name, "S-Video");
1913         } else {
1914                 sprintf(i->name, "Composite%d", i->index);
1915         }
1916
1917         if (i->index == btv->input) {
1918                 __u32 dstatus = btread(BT848_DSTATUS);
1919                 if (0 == (dstatus & BT848_DSTATUS_PRES))
1920                         i->status |= V4L2_IN_ST_NO_SIGNAL;
1921                 if (0 == (dstatus & BT848_DSTATUS_HLOC))
1922                         i->status |= V4L2_IN_ST_NO_H_LOCK;
1923         }
1924
1925         i->std = BTTV_NORMS;
1926
1927 err:
1928
1929         return rc;
1930 }
1931
1932 static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
1933 {
1934         struct bttv_fh *fh = priv;
1935         struct bttv *btv = fh->btv;
1936
1937         *i = btv->input;
1938
1939         return 0;
1940 }
1941
1942 static int bttv_s_input(struct file *file, void *priv, unsigned int i)
1943 {
1944         struct bttv_fh *fh  = priv;
1945         struct bttv *btv = fh->btv;
1946
1947         int err;
1948
1949         err = v4l2_prio_check(&btv->prio, fh->prio);
1950         if (unlikely(err))
1951                 goto err;
1952
1953         if (i > bttv_tvcards[btv->c.type].video_inputs) {
1954                 err = -EINVAL;
1955                 goto err;
1956         }
1957
1958         set_input(btv, i, btv->tvnorm);
1959
1960 err:
1961         return 0;
1962 }
1963
1964 static int bttv_s_tuner(struct file *file, void *priv,
1965                                         struct v4l2_tuner *t)
1966 {
1967         struct bttv_fh *fh  = priv;
1968         struct bttv *btv = fh->btv;
1969         int err;
1970
1971         if (unlikely(0 != t->index))
1972                 return -EINVAL;
1973
1974         if (unlikely(btv->tuner_type == TUNER_ABSENT)) {
1975                 err = -EINVAL;
1976                 goto err;
1977         }
1978
1979         err = v4l2_prio_check(&btv->prio, fh->prio);
1980         if (unlikely(err))
1981                 goto err;
1982
1983         bttv_call_all(btv, tuner, s_tuner, t);
1984
1985         if (btv->audio_mode_gpio)
1986                 btv->audio_mode_gpio(btv, t, 1);
1987
1988 err:
1989
1990         return 0;
1991 }
1992
1993 static int bttv_g_frequency(struct file *file, void *priv,
1994                                         struct v4l2_frequency *f)
1995 {
1996         struct bttv_fh *fh  = priv;
1997         struct bttv *btv = fh->btv;
1998
1999         f->type = btv->radio_user ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
2000         f->frequency = btv->freq;
2001
2002         return 0;
2003 }
2004
2005 static int bttv_s_frequency(struct file *file, void *priv,
2006                                         struct v4l2_frequency *f)
2007 {
2008         struct bttv_fh *fh  = priv;
2009         struct bttv *btv = fh->btv;
2010         int err;
2011
2012         if (unlikely(f->tuner != 0))
2013                 return -EINVAL;
2014
2015         err = v4l2_prio_check(&btv->prio, fh->prio);
2016         if (unlikely(err))
2017                 goto err;
2018
2019         if (unlikely(f->type != (btv->radio_user
2020                 ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV))) {
2021                 err = -EINVAL;
2022                 goto err;
2023         }
2024         btv->freq = f->frequency;
2025         bttv_call_all(btv, tuner, s_frequency, f);
2026         if (btv->has_matchbox && btv->radio_user)
2027                 tea5757_set_freq(btv, btv->freq);
2028 err:
2029
2030         return 0;
2031 }
2032
2033 static int bttv_log_status(struct file *file, void *f)
2034 {
2035         struct bttv_fh *fh  = f;
2036         struct bttv *btv = fh->btv;
2037
2038         pr_info("%d: ========  START STATUS CARD #%d  ========\n",
2039                 btv->c.nr, btv->c.nr);
2040         bttv_call_all(btv, core, log_status);
2041         pr_info("%d: ========  END STATUS CARD   #%d  ========\n",
2042                 btv->c.nr, btv->c.nr);
2043         return 0;
2044 }
2045
2046 #ifdef CONFIG_VIDEO_ADV_DEBUG
2047 static int bttv_g_register(struct file *file, void *f,
2048                                         struct v4l2_dbg_register *reg)
2049 {
2050         struct bttv_fh *fh = f;
2051         struct bttv *btv = fh->btv;
2052
2053         if (!capable(CAP_SYS_ADMIN))
2054                 return -EPERM;
2055
2056         if (!v4l2_chip_match_host(&reg->match))
2057                 return -EINVAL;
2058
2059         /* bt848 has a 12-bit register space */
2060         reg->reg &= 0xfff;
2061         reg->val = btread(reg->reg);
2062         reg->size = 1;
2063
2064         return 0;
2065 }
2066
2067 static int bttv_s_register(struct file *file, void *f,
2068                                         struct v4l2_dbg_register *reg)
2069 {
2070         struct bttv_fh *fh = f;
2071         struct bttv *btv = fh->btv;
2072
2073         if (!capable(CAP_SYS_ADMIN))
2074                 return -EPERM;
2075
2076         if (!v4l2_chip_match_host(&reg->match))
2077                 return -EINVAL;
2078
2079         /* bt848 has a 12-bit register space */
2080         reg->reg &= 0xfff;
2081         btwrite(reg->val, reg->reg);
2082
2083         return 0;
2084 }
2085 #endif
2086
2087 /* Given cropping boundaries b and the scaled width and height of a
2088    single field or frame, which must not exceed hardware limits, this
2089    function adjusts the cropping parameters c. */
2090 static void
2091 bttv_crop_adjust        (struct bttv_crop *             c,
2092                          const struct v4l2_rect *       b,
2093                          __s32                          width,
2094                          __s32                          height,
2095                          enum v4l2_field                field)
2096 {
2097         __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
2098         __s32 max_left;
2099         __s32 max_top;
2100
2101         if (width < c->min_scaled_width) {
2102                 /* Max. hor. scale factor 16:1. */
2103                 c->rect.width = width * 16;
2104         } else if (width > c->max_scaled_width) {
2105                 /* Min. hor. scale factor 1:1. */
2106                 c->rect.width = width;
2107
2108                 max_left = b->left + b->width - width;
2109                 max_left = min(max_left, (__s32) MAX_HDELAY);
2110                 if (c->rect.left > max_left)
2111                         c->rect.left = max_left;
2112         }
2113
2114         if (height < c->min_scaled_height) {
2115                 /* Max. vert. scale factor 16:1, single fields 8:1. */
2116                 c->rect.height = height * 16;
2117         } else if (frame_height > c->max_scaled_height) {
2118                 /* Min. vert. scale factor 1:1.
2119                    Top and height count field lines times two. */
2120                 c->rect.height = (frame_height + 1) & ~1;
2121
2122                 max_top = b->top + b->height - c->rect.height;
2123                 if (c->rect.top > max_top)
2124                         c->rect.top = max_top;
2125         }
2126
2127         bttv_crop_calc_limits(c);
2128 }
2129
2130 /* Returns an error if scaling to a frame or single field with the given
2131    width and height is not possible with the current cropping parameters
2132    and width aligned according to width_mask. If adjust_size is TRUE the
2133    function may adjust the width and/or height instead, rounding width
2134    to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
2135    also adjust the current cropping parameters to get closer to the
2136    desired image size. */
2137 static int
2138 limit_scaled_size_lock       (struct bttv_fh *               fh,
2139                          __s32 *                        width,
2140                          __s32 *                        height,
2141                          enum v4l2_field                field,
2142                          unsigned int                   width_mask,
2143                          unsigned int                   width_bias,
2144                          int                            adjust_size,
2145                          int                            adjust_crop)
2146 {
2147         struct bttv *btv = fh->btv;
2148         const struct v4l2_rect *b;
2149         struct bttv_crop *c;
2150         __s32 min_width;
2151         __s32 min_height;
2152         __s32 max_width;
2153         __s32 max_height;
2154         int rc;
2155
2156         BUG_ON((int) width_mask >= 0 ||
2157                width_bias >= (unsigned int) -width_mask);
2158
2159         /* Make sure tvnorm, vbi_end and the current cropping parameters
2160            remain consistent until we're done. */
2161
2162         b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2163
2164         /* Do crop - use current, don't - use default parameters. */
2165         c = &btv->crop[!!fh->do_crop];
2166
2167         if (fh->do_crop
2168             && adjust_size
2169             && adjust_crop
2170             && !locked_btres(btv, VIDEO_RESOURCES)) {
2171                 min_width = 48;
2172                 min_height = 32;
2173
2174                 /* We cannot scale up. When the scaled image is larger
2175                    than crop.rect we adjust the crop.rect as required
2176                    by the V4L2 spec, hence cropcap.bounds are our limit. */
2177                 max_width = min(b->width, (__s32) MAX_HACTIVE);
2178                 max_height = b->height;
2179
2180                 /* We cannot capture the same line as video and VBI data.
2181                    Note btv->vbi_end is really a minimum, see
2182                    bttv_vbi_try_fmt(). */
2183                 if (btv->vbi_end > b->top) {
2184                         max_height -= btv->vbi_end - b->top;
2185                         rc = -EBUSY;
2186                         if (min_height > max_height)
2187                                 goto fail;
2188                 }
2189         } else {
2190                 rc = -EBUSY;
2191                 if (btv->vbi_end > c->rect.top)
2192                         goto fail;
2193
2194                 min_width  = c->min_scaled_width;
2195                 min_height = c->min_scaled_height;
2196                 max_width  = c->max_scaled_width;
2197                 max_height = c->max_scaled_height;
2198
2199                 adjust_crop = 0;
2200         }
2201
2202         min_width = (min_width - width_mask - 1) & width_mask;
2203         max_width = max_width & width_mask;
2204
2205         /* Max. scale factor is 16:1 for frames, 8:1 for fields. */
2206         min_height = min_height;
2207         /* Min. scale factor is 1:1. */
2208         max_height >>= !V4L2_FIELD_HAS_BOTH(field);
2209
2210         if (adjust_size) {
2211                 *width = clamp(*width, min_width, max_width);
2212                 *height = clamp(*height, min_height, max_height);
2213
2214                 /* Round after clamping to avoid overflow. */
2215                 *width = (*width + width_bias) & width_mask;
2216
2217                 if (adjust_crop) {
2218                         bttv_crop_adjust(c, b, *width, *height, field);
2219
2220                         if (btv->vbi_end > c->rect.top) {
2221                                 /* Move the crop window out of the way. */
2222                                 c->rect.top = btv->vbi_end;
2223                         }
2224                 }
2225         } else {
2226                 rc = -EINVAL;
2227                 if (*width  < min_width ||
2228                     *height < min_height ||
2229                     *width  > max_width ||
2230                     *height > max_height ||
2231                     0 != (*width & ~width_mask))
2232                         goto fail;
2233         }
2234
2235         rc = 0; /* success */
2236
2237  fail:
2238
2239         return rc;
2240 }
2241
2242 /* Returns an error if the given overlay window dimensions are not
2243    possible with the current cropping parameters. If adjust_size is
2244    TRUE the function may adjust the window width and/or height
2245    instead, however it always rounds the horizontal position and
2246    width as btcx_align() does. If adjust_crop is TRUE the function
2247    may also adjust the current cropping parameters to get closer
2248    to the desired window size. */
2249 static int
2250 verify_window_lock              (struct bttv_fh *               fh,
2251                          struct v4l2_window *           win,
2252                          int                            adjust_size,
2253                          int                            adjust_crop)
2254 {
2255         enum v4l2_field field;
2256         unsigned int width_mask;
2257         int rc;
2258
2259         if (win->w.width  < 48 || win->w.height < 32)
2260                 return -EINVAL;
2261         if (win->clipcount > 2048)
2262                 return -EINVAL;
2263
2264         field = win->field;
2265
2266         if (V4L2_FIELD_ANY == field) {
2267                 __s32 height2;
2268
2269                 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2270                 field = (win->w.height > height2)
2271                         ? V4L2_FIELD_INTERLACED
2272                         : V4L2_FIELD_TOP;
2273         }
2274         switch (field) {
2275         case V4L2_FIELD_TOP:
2276         case V4L2_FIELD_BOTTOM:
2277         case V4L2_FIELD_INTERLACED:
2278                 break;
2279         default:
2280                 return -EINVAL;
2281         }
2282
2283         /* 4-byte alignment. */
2284         if (NULL == fh->ovfmt)
2285                 return -EINVAL;
2286         width_mask = ~0;
2287         switch (fh->ovfmt->depth) {
2288         case 8:
2289         case 24:
2290                 width_mask = ~3;
2291                 break;
2292         case 16:
2293                 width_mask = ~1;
2294                 break;
2295         case 32:
2296                 break;
2297         default:
2298                 BUG();
2299         }
2300
2301         win->w.width -= win->w.left & ~width_mask;
2302         win->w.left = (win->w.left - width_mask - 1) & width_mask;
2303
2304         rc = limit_scaled_size_lock(fh, &win->w.width, &win->w.height,
2305                                field, width_mask,
2306                                /* width_bias: round down */ 0,
2307                                adjust_size, adjust_crop);
2308         if (0 != rc)
2309                 return rc;
2310
2311         win->field = field;
2312         return 0;
2313 }
2314
2315 static int setup_window_lock(struct bttv_fh *fh, struct bttv *btv,
2316                         struct v4l2_window *win, int fixup)
2317 {
2318         struct v4l2_clip *clips = NULL;
2319         int n,size,retval = 0;
2320
2321         if (NULL == fh->ovfmt)
2322                 return -EINVAL;
2323         if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2324                 return -EINVAL;
2325         retval = verify_window_lock(fh, win,
2326                                /* adjust_size */ fixup,
2327                                /* adjust_crop */ fixup);
2328         if (0 != retval)
2329                 return retval;
2330
2331         /* copy clips  --  luckily v4l1 + v4l2 are binary
2332            compatible here ...*/
2333         n = win->clipcount;
2334         size = sizeof(*clips)*(n+4);
2335         clips = kmalloc(size,GFP_KERNEL);
2336         if (NULL == clips)
2337                 return -ENOMEM;
2338         if (n > 0) {
2339                 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2340                         kfree(clips);
2341                         return -EFAULT;
2342                 }
2343         }
2344
2345         /* clip against screen */
2346         if (NULL != btv->fbuf.base)
2347                 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2348                                       &win->w, clips, n);
2349         btcx_sort_clips(clips,n);
2350
2351         /* 4-byte alignments */
2352         switch (fh->ovfmt->depth) {
2353         case 8:
2354         case 24:
2355                 btcx_align(&win->w, clips, n, 3);
2356                 break;
2357         case 16:
2358                 btcx_align(&win->w, clips, n, 1);
2359                 break;
2360         case 32:
2361                 /* no alignment fixups needed */
2362                 break;
2363         default:
2364                 BUG();
2365         }
2366
2367         kfree(fh->ov.clips);
2368         fh->ov.clips    = clips;
2369         fh->ov.nclips   = n;
2370
2371         fh->ov.w        = win->w;
2372         fh->ov.field    = win->field;
2373         fh->ov.setup_ok = 1;
2374
2375         btv->init.ov.w.width   = win->w.width;
2376         btv->init.ov.w.height  = win->w.height;
2377         btv->init.ov.field     = win->field;
2378
2379         /* update overlay if needed */
2380         retval = 0;
2381         if (check_btres(fh, RESOURCE_OVERLAY)) {
2382                 struct bttv_buffer *new;
2383
2384                 new = videobuf_sg_alloc(sizeof(*new));
2385                 new->crop = btv->crop[!!fh->do_crop].rect;
2386                 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2387                 retval = bttv_switch_overlay(btv,fh,new);
2388         }
2389         return retval;
2390 }
2391
2392 /* ----------------------------------------------------------------------- */
2393
2394 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2395 {
2396         struct videobuf_queue* q = NULL;
2397
2398         switch (fh->type) {
2399         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2400                 q = &fh->cap;
2401                 break;
2402         case V4L2_BUF_TYPE_VBI_CAPTURE:
2403                 q = &fh->vbi;
2404                 break;
2405         default:
2406                 BUG();
2407         }
2408         return q;
2409 }
2410
2411 static int bttv_resource(struct bttv_fh *fh)
2412 {
2413         int res = 0;
2414
2415         switch (fh->type) {
2416         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2417                 res = RESOURCE_VIDEO_STREAM;
2418                 break;
2419         case V4L2_BUF_TYPE_VBI_CAPTURE:
2420                 res = RESOURCE_VBI;
2421                 break;
2422         default:
2423                 BUG();
2424         }
2425         return res;
2426 }
2427
2428 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2429 {
2430         struct videobuf_queue *q = bttv_queue(fh);
2431         int res = bttv_resource(fh);
2432
2433         if (check_btres(fh,res))
2434                 return -EBUSY;
2435         if (videobuf_queue_is_busy(q))
2436                 return -EBUSY;
2437         fh->type = type;
2438         return 0;
2439 }
2440
2441 static void
2442 pix_format_set_size     (struct v4l2_pix_format *       f,
2443                          const struct bttv_format *     fmt,
2444                          unsigned int                   width,
2445                          unsigned int                   height)
2446 {
2447         f->width = width;
2448         f->height = height;
2449
2450         if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2451                 f->bytesperline = width; /* Y plane */
2452                 f->sizeimage = (width * height * fmt->depth) >> 3;
2453         } else {
2454                 f->bytesperline = (width * fmt->depth) >> 3;
2455                 f->sizeimage = height * f->bytesperline;
2456         }
2457 }
2458
2459 static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
2460                                         struct v4l2_format *f)
2461 {
2462         struct bttv_fh *fh  = priv;
2463
2464         pix_format_set_size(&f->fmt.pix, fh->fmt,
2465                                 fh->width, fh->height);
2466         f->fmt.pix.field        = fh->cap.field;
2467         f->fmt.pix.pixelformat  = fh->fmt->fourcc;
2468
2469         return 0;
2470 }
2471
2472 static int bttv_g_fmt_vid_overlay(struct file *file, void *priv,
2473                                         struct v4l2_format *f)
2474 {
2475         struct bttv_fh *fh  = priv;
2476
2477         f->fmt.win.w     = fh->ov.w;
2478         f->fmt.win.field = fh->ov.field;
2479
2480         return 0;
2481 }
2482
2483 static void bttv_get_width_mask_vid_cap(const struct bttv_format *fmt,
2484                                         unsigned int *width_mask,
2485                                         unsigned int *width_bias)
2486 {
2487         if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2488                 *width_mask = ~15; /* width must be a multiple of 16 pixels */
2489                 *width_bias = 8;   /* nearest */
2490         } else {
2491                 *width_mask = ~3; /* width must be a multiple of 4 pixels */
2492                 *width_bias = 2;  /* nearest */
2493         }
2494 }
2495
2496 static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
2497                                                 struct v4l2_format *f)
2498 {
2499         const struct bttv_format *fmt;
2500         struct bttv_fh *fh = priv;
2501         struct bttv *btv = fh->btv;
2502         enum v4l2_field field;
2503         __s32 width, height;
2504         unsigned int width_mask, width_bias;
2505         int rc;
2506
2507         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2508         if (NULL == fmt)
2509                 return -EINVAL;
2510
2511         field = f->fmt.pix.field;
2512
2513         if (V4L2_FIELD_ANY == field) {
2514                 __s32 height2;
2515
2516                 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2517                 field = (f->fmt.pix.height > height2)
2518                         ? V4L2_FIELD_INTERLACED
2519                         : V4L2_FIELD_BOTTOM;
2520         }
2521
2522         if (V4L2_FIELD_SEQ_BT == field)
2523                 field = V4L2_FIELD_SEQ_TB;
2524
2525         switch (field) {
2526         case V4L2_FIELD_TOP:
2527         case V4L2_FIELD_BOTTOM:
2528         case V4L2_FIELD_ALTERNATE:
2529         case V4L2_FIELD_INTERLACED:
2530                 break;
2531         case V4L2_FIELD_SEQ_TB:
2532                 if (fmt->flags & FORMAT_FLAGS_PLANAR)
2533                         return -EINVAL;
2534                 break;
2535         default:
2536                 return -EINVAL;
2537         }
2538
2539         width = f->fmt.pix.width;
2540         height = f->fmt.pix.height;
2541
2542         bttv_get_width_mask_vid_cap(fmt, &width_mask, &width_bias);
2543         rc = limit_scaled_size_lock(fh, &width, &height, field,
2544                                width_mask, width_bias,
2545                                /* adjust_size */ 1,
2546                                /* adjust_crop */ 0);
2547         if (0 != rc)
2548                 return rc;
2549
2550         /* update data for the application */
2551         f->fmt.pix.field = field;
2552         pix_format_set_size(&f->fmt.pix, fmt, width, height);
2553
2554         return 0;
2555 }
2556
2557 static int bttv_try_fmt_vid_overlay(struct file *file, void *priv,
2558                                                 struct v4l2_format *f)
2559 {
2560         struct bttv_fh *fh = priv;
2561
2562         return verify_window_lock(fh, &f->fmt.win,
2563                         /* adjust_size */ 1,
2564                         /* adjust_crop */ 0);
2565 }
2566
2567 static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2568                                 struct v4l2_format *f)
2569 {
2570         int retval;
2571         const struct bttv_format *fmt;
2572         struct bttv_fh *fh = priv;
2573         struct bttv *btv = fh->btv;
2574         __s32 width, height;
2575         unsigned int width_mask, width_bias;
2576         enum v4l2_field field;
2577
2578         retval = bttv_switch_type(fh, f->type);
2579         if (0 != retval)
2580                 return retval;
2581
2582         retval = bttv_try_fmt_vid_cap(file, priv, f);
2583         if (0 != retval)
2584                 return retval;
2585
2586         width = f->fmt.pix.width;
2587         height = f->fmt.pix.height;
2588         field = f->fmt.pix.field;
2589
2590         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2591         bttv_get_width_mask_vid_cap(fmt, &width_mask, &width_bias);
2592         retval = limit_scaled_size_lock(fh, &width, &height, f->fmt.pix.field,
2593                                width_mask, width_bias,
2594                                /* adjust_size */ 1,
2595                                /* adjust_crop */ 1);
2596         if (0 != retval)
2597                 return retval;
2598
2599         f->fmt.pix.field = field;
2600
2601         /* update our state informations */
2602         fh->fmt              = fmt;
2603         fh->cap.field        = f->fmt.pix.field;
2604         fh->cap.last         = V4L2_FIELD_NONE;
2605         fh->width            = f->fmt.pix.width;
2606         fh->height           = f->fmt.pix.height;
2607         btv->init.fmt        = fmt;
2608         btv->init.width      = f->fmt.pix.width;
2609         btv->init.height     = f->fmt.pix.height;
2610
2611         return 0;
2612 }
2613
2614 static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
2615                                 struct v4l2_format *f)
2616 {
2617         struct bttv_fh *fh = priv;
2618         struct bttv *btv = fh->btv;
2619
2620         if (no_overlay > 0) {
2621                 pr_err("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2622                 return -EINVAL;
2623         }
2624
2625         return setup_window_lock(fh, btv, &f->fmt.win, 1);
2626 }
2627
2628 static int bttv_querycap(struct file *file, void  *priv,
2629                                 struct v4l2_capability *cap)
2630 {
2631         struct bttv_fh *fh = priv;
2632         struct bttv *btv = fh->btv;
2633
2634         if (0 == v4l2)
2635                 return -EINVAL;
2636
2637         strlcpy(cap->driver, "bttv", sizeof(cap->driver));
2638         strlcpy(cap->card, btv->video_dev->name, sizeof(cap->card));
2639         snprintf(cap->bus_info, sizeof(cap->bus_info),
2640                  "PCI:%s", pci_name(btv->c.pci));
2641         cap->capabilities =
2642                 V4L2_CAP_VIDEO_CAPTURE |
2643                 V4L2_CAP_VBI_CAPTURE |
2644                 V4L2_CAP_READWRITE |
2645                 V4L2_CAP_STREAMING;
2646         if (no_overlay <= 0)
2647                 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2648
2649         /*
2650          * No need to lock here: those vars are initialized during board
2651          * probe and remains untouched during the rest of the driver lifecycle
2652          */
2653         if (btv->has_saa6588)
2654                 cap->capabilities |= V4L2_CAP_RDS_CAPTURE;
2655         if (btv->tuner_type != TUNER_ABSENT)
2656                 cap->capabilities |= V4L2_CAP_TUNER;
2657         return 0;
2658 }
2659
2660 static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f)
2661 {
2662         int index = -1, i;
2663
2664         for (i = 0; i < FORMATS; i++) {
2665                 if (formats[i].fourcc != -1)
2666                         index++;
2667                 if ((unsigned int)index == f->index)
2668                         break;
2669         }
2670         if (FORMATS == i)
2671                 return -EINVAL;
2672
2673         f->pixelformat = formats[i].fourcc;
2674         strlcpy(f->description, formats[i].name, sizeof(f->description));
2675
2676         return i;
2677 }
2678
2679 static int bttv_enum_fmt_vid_cap(struct file *file, void  *priv,
2680                                 struct v4l2_fmtdesc *f)
2681 {
2682         int rc = bttv_enum_fmt_cap_ovr(f);
2683
2684         if (rc < 0)
2685                 return rc;
2686
2687         return 0;
2688 }
2689
2690 static int bttv_enum_fmt_vid_overlay(struct file *file, void  *priv,
2691                                         struct v4l2_fmtdesc *f)
2692 {
2693         int rc;
2694
2695         if (no_overlay > 0) {
2696                 pr_err("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2697                 return -EINVAL;
2698         }
2699
2700         rc = bttv_enum_fmt_cap_ovr(f);
2701
2702         if (rc < 0)
2703                 return rc;
2704
2705         if (!(formats[rc].flags & FORMAT_FLAGS_PACKED))
2706                 return -EINVAL;
2707
2708         return 0;
2709 }
2710
2711 static int bttv_g_fbuf(struct file *file, void *f,
2712                                 struct v4l2_framebuffer *fb)
2713 {
2714         struct bttv_fh *fh = f;
2715         struct bttv *btv = fh->btv;
2716
2717         *fb = btv->fbuf;
2718         fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2719         if (fh->ovfmt)
2720                 fb->fmt.pixelformat  = fh->ovfmt->fourcc;
2721         return 0;
2722 }
2723
2724 static int bttv_overlay(struct file *file, void *f, unsigned int on)
2725 {
2726         struct bttv_fh *fh = f;
2727         struct bttv *btv = fh->btv;
2728         struct bttv_buffer *new;
2729         int retval = 0;
2730
2731         if (on) {
2732                 /* verify args */
2733                 if (unlikely(!btv->fbuf.base)) {
2734                         return -EINVAL;
2735                 }
2736                 if (unlikely(!fh->ov.setup_ok)) {
2737                         dprintk("%d: overlay: !setup_ok\n", btv->c.nr);
2738                         retval = -EINVAL;
2739                 }
2740                 if (retval)
2741                         return retval;
2742         }
2743
2744         if (!check_alloc_btres_lock(btv, fh, RESOURCE_OVERLAY))
2745                 return -EBUSY;
2746
2747         if (on) {
2748                 fh->ov.tvnorm = btv->tvnorm;
2749                 new = videobuf_sg_alloc(sizeof(*new));
2750                 new->crop = btv->crop[!!fh->do_crop].rect;
2751                 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2752         } else {
2753                 new = NULL;
2754         }
2755
2756         /* switch over */
2757         retval = bttv_switch_overlay(btv, fh, new);
2758         return retval;
2759 }
2760
2761 static int bttv_s_fbuf(struct file *file, void *f,
2762                                 struct v4l2_framebuffer *fb)
2763 {
2764         struct bttv_fh *fh = f;
2765         struct bttv *btv = fh->btv;
2766         const struct bttv_format *fmt;
2767         int retval;
2768
2769         if (!capable(CAP_SYS_ADMIN) &&
2770                 !capable(CAP_SYS_RAWIO))
2771                 return -EPERM;
2772
2773         /* check args */
2774         fmt = format_by_fourcc(fb->fmt.pixelformat);
2775         if (NULL == fmt)
2776                 return -EINVAL;
2777         if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2778                 return -EINVAL;
2779
2780         retval = -EINVAL;
2781         if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2782                 __s32 width = fb->fmt.width;
2783                 __s32 height = fb->fmt.height;
2784
2785                 retval = limit_scaled_size_lock(fh, &width, &height,
2786                                            V4L2_FIELD_INTERLACED,
2787                                            /* width_mask */ ~3,
2788                                            /* width_bias */ 2,
2789                                            /* adjust_size */ 0,
2790                                            /* adjust_crop */ 0);
2791                 if (0 != retval)
2792                         return retval;
2793         }
2794
2795         /* ok, accept it */
2796         btv->fbuf.base       = fb->base;
2797         btv->fbuf.fmt.width  = fb->fmt.width;
2798         btv->fbuf.fmt.height = fb->fmt.height;
2799         if (0 != fb->fmt.bytesperline)
2800                 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2801         else
2802                 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2803
2804         retval = 0;
2805         fh->ovfmt = fmt;
2806         btv->init.ovfmt = fmt;
2807         if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2808                 fh->ov.w.left   = 0;
2809                 fh->ov.w.top    = 0;
2810                 fh->ov.w.width  = fb->fmt.width;
2811                 fh->ov.w.height = fb->fmt.height;
2812                 btv->init.ov.w.width  = fb->fmt.width;
2813                 btv->init.ov.w.height = fb->fmt.height;
2814                         kfree(fh->ov.clips);
2815                 fh->ov.clips = NULL;
2816                 fh->ov.nclips = 0;
2817
2818                 if (check_btres(fh, RESOURCE_OVERLAY)) {
2819                         struct bttv_buffer *new;
2820
2821                         new = videobuf_sg_alloc(sizeof(*new));
2822                         new->crop = btv->crop[!!fh->do_crop].rect;
2823                         bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2824                         retval = bttv_switch_overlay(btv, fh, new);
2825                 }
2826         }
2827         return retval;
2828 }
2829
2830 static int bttv_reqbufs(struct file *file, void *priv,
2831                                 struct v4l2_requestbuffers *p)
2832 {
2833         struct bttv_fh *fh = priv;
2834         return videobuf_reqbufs(bttv_queue(fh), p);
2835 }
2836
2837 static int bttv_querybuf(struct file *file, void *priv,
2838                                 struct v4l2_buffer *b)
2839 {
2840         struct bttv_fh *fh = priv;
2841         return videobuf_querybuf(bttv_queue(fh), b);
2842 }
2843
2844 static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2845 {
2846         struct bttv_fh *fh = priv;
2847         struct bttv *btv = fh->btv;
2848         int res = bttv_resource(fh);
2849
2850         if (!check_alloc_btres_lock(btv, fh, res))
2851                 return -EBUSY;
2852
2853         return videobuf_qbuf(bttv_queue(fh), b);
2854 }
2855
2856 static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2857 {
2858         struct bttv_fh *fh = priv;
2859         return videobuf_dqbuf(bttv_queue(fh), b,
2860                         file->f_flags & O_NONBLOCK);
2861 }
2862
2863 static int bttv_streamon(struct file *file, void *priv,
2864                                         enum v4l2_buf_type type)
2865 {
2866         struct bttv_fh *fh = priv;
2867         struct bttv *btv = fh->btv;
2868         int res = bttv_resource(fh);
2869
2870         if (!check_alloc_btres_lock(btv, fh, res))
2871                 return -EBUSY;
2872         return videobuf_streamon(bttv_queue(fh));
2873 }
2874
2875
2876 static int bttv_streamoff(struct file *file, void *priv,
2877                                         enum v4l2_buf_type type)
2878 {
2879         struct bttv_fh *fh = priv;
2880         struct bttv *btv = fh->btv;
2881         int retval;
2882         int res = bttv_resource(fh);
2883
2884
2885         retval = videobuf_streamoff(bttv_queue(fh));
2886         if (retval < 0)
2887                 return retval;
2888         free_btres_lock(btv, fh, res);
2889         return 0;
2890 }
2891
2892 static int bttv_queryctrl(struct file *file, void *priv,
2893                                         struct v4l2_queryctrl *c)
2894 {
2895         struct bttv_fh *fh = priv;
2896         struct bttv *btv = fh->btv;
2897         const struct v4l2_queryctrl *ctrl;
2898
2899         if ((c->id <  V4L2_CID_BASE ||
2900              c->id >= V4L2_CID_LASTP1) &&
2901             (c->id <  V4L2_CID_PRIVATE_BASE ||
2902              c->id >= V4L2_CID_PRIVATE_LASTP1))
2903                 return -EINVAL;
2904
2905         if (!btv->volume_gpio && (c->id == V4L2_CID_AUDIO_VOLUME))
2906                 *c = no_ctl;
2907         else {
2908                 ctrl = ctrl_by_id(c->id);
2909
2910                 *c = (NULL != ctrl) ? *ctrl : no_ctl;
2911         }
2912
2913         return 0;
2914 }
2915
2916 static int bttv_g_parm(struct file *file, void *f,
2917                                 struct v4l2_streamparm *parm)
2918 {
2919         struct bttv_fh *fh = f;
2920         struct bttv *btv = fh->btv;
2921
2922         v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id,
2923                                     &parm->parm.capture.timeperframe);
2924
2925         return 0;
2926 }
2927
2928 static int bttv_g_tuner(struct file *file, void *priv,
2929                                 struct v4l2_tuner *t)
2930 {
2931         struct bttv_fh *fh = priv;
2932         struct bttv *btv = fh->btv;
2933
2934         if (btv->tuner_type == TUNER_ABSENT)
2935                 return -EINVAL;
2936         if (0 != t->index)
2937                 return -EINVAL;
2938
2939         t->rxsubchans = V4L2_TUNER_SUB_MONO;
2940         bttv_call_all(btv, tuner, g_tuner, t);
2941         strcpy(t->name, "Television");
2942         t->capability = V4L2_TUNER_CAP_NORM;
2943         t->type       = V4L2_TUNER_ANALOG_TV;
2944         if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2945                 t->signal = 0xffff;
2946
2947         if (btv->audio_mode_gpio)
2948                 btv->audio_mode_gpio(btv, t, 0);
2949
2950         return 0;
2951 }
2952
2953 static int bttv_g_priority(struct file *file, void *f, enum v4l2_priority *p)
2954 {
2955         struct bttv_fh *fh = f;
2956         struct bttv *btv = fh->btv;
2957
2958         *p = v4l2_prio_max(&btv->prio);
2959
2960         return 0;
2961 }
2962
2963 static int bttv_s_priority(struct file *file, void *f,
2964                                         enum v4l2_priority prio)
2965 {
2966         struct bttv_fh *fh = f;
2967         struct bttv *btv = fh->btv;
2968         int     rc;
2969
2970         rc = v4l2_prio_change(&btv->prio, &fh->prio, prio);