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

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