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

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