Version:  2.0.40 2.2.26 2.4.37 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0

Linux/drivers/media/pci/bt8xx/bttv-driver.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us