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