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

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