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

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