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