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 = video_get_drvdata(vfd);
 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
1167         gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
1168                    bttv_tvcards[btv->c.type].gpiomask);
1169         signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
1170
1171         btv->mute = mute;
1172         btv->audio = input;
1173
1174         /* automute */
1175         mute = mute || (btv->opt_automute && !signal && !btv->radio_user);
1176
1177         if (mute)
1178                 gpio_val = bttv_tvcards[btv->c.type].gpiomute;
1179         else
1180                 gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
1181
1182         switch (btv->c.type) {
1183         case BTTV_BOARD_VOODOOTV_FM:
1184         case BTTV_BOARD_VOODOOTV_200:
1185                 gpio_val = bttv_tda9880_setnorm(btv, gpio_val);
1186                 break;
1187
1188         default:
1189                 gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
1190         }
1191
1192         if (bttv_gpio)
1193                 bttv_gpio_tracking(btv, audio_modes[mute ? 4 : input]);
1194         if (in_interrupt())
1195                 return 0;
1196
1197         ctrl.id = V4L2_CID_AUDIO_MUTE;
1198         ctrl.value = btv->mute;
1199         bttv_call_all(btv, core, s_ctrl, &ctrl);
1200         if (btv->sd_msp34xx) {
1201                 u32 in;
1202
1203                 /* Note: the inputs tuner/radio/extern/intern are translated
1204                    to msp routings. This assumes common behavior for all msp3400
1205                    based TV cards. When this assumption fails, then the
1206                    specific MSP routing must be added to the card table.
1207                    For now this is sufficient. */
1208                 switch (input) {
1209                 case TVAUDIO_INPUT_RADIO:
1210                         in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1211                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1212                         break;
1213                 case TVAUDIO_INPUT_EXTERN:
1214                         in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
1215                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1216                         break;
1217                 case TVAUDIO_INPUT_INTERN:
1218                         /* Yes, this is the same input as for RADIO. I doubt
1219                            if this is ever used. The only board with an INTERN
1220                            input is the BTTV_BOARD_AVERMEDIA98. I wonder how
1221                            that was tested. My guess is that the whole INTERN
1222                            input does not work. */
1223                         in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1224                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1225                         break;
1226                 case TVAUDIO_INPUT_TUNER:
1227                 default:
1228                         /* This is the only card that uses TUNER2, and afaik,
1229                            is the only difference between the VOODOOTV_FM
1230                            and VOODOOTV_200 */
1231                         if (btv->c.type == BTTV_BOARD_VOODOOTV_200)
1232                                 in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \
1233                                         MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER);
1234                         else
1235                                 in = MSP_INPUT_DEFAULT;
1236                         break;
1237                 }
1238                 v4l2_subdev_call(btv->sd_msp34xx, audio, s_routing,
1239                                in, MSP_OUTPUT_DEFAULT, 0);
1240         }
1241         if (btv->sd_tvaudio) {
1242                 v4l2_subdev_call(btv->sd_tvaudio, audio, s_routing,
1243                                 input, 0, 0);
1244         }
1245         return 0;
1246 }
1247
1248 static inline int
1249 audio_mute(struct bttv *btv, int mute)
1250 {
1251         return audio_mux(btv, btv->audio, mute);
1252 }
1253
1254 static inline int
1255 audio_input(struct bttv *btv, int input)
1256 {
1257         return audio_mux(btv, input, btv->mute);
1258 }
1259
1260 static void
1261 bttv_crop_calc_limits(struct bttv_crop *c)
1262 {
1263         /* Scale factor min. 1:1, max. 16:1. Min. image size
1264            48 x 32. Scaled width must be a multiple of 4. */
1265
1266         if (1) {
1267                 /* For bug compatibility with VIDIOCGCAP and image
1268                    size checks in earlier driver versions. */
1269                 c->min_scaled_width = 48;
1270                 c->min_scaled_height = 32;
1271         } else {
1272                 c->min_scaled_width =
1273                         (max(48, c->rect.width >> 4) + 3) & ~3;
1274                 c->min_scaled_height =
1275                         max(32, c->rect.height >> 4);
1276         }
1277
1278         c->max_scaled_width  = c->rect.width & ~3;
1279         c->max_scaled_height = c->rect.height;
1280 }
1281
1282 static void
1283 bttv_crop_reset(struct bttv_crop *c, unsigned int norm)
1284 {
1285         c->rect = bttv_tvnorms[norm].cropcap.defrect;
1286         bttv_crop_calc_limits(c);
1287 }
1288
1289 /* Call with btv->lock down. */
1290 static int
1291 set_tvnorm(struct bttv *btv, unsigned int norm)
1292 {
1293         const struct bttv_tvnorm *tvnorm;
1294         v4l2_std_id id;
1295
1296         BUG_ON(norm >= BTTV_TVNORMS);
1297         BUG_ON(btv->tvnorm >= BTTV_TVNORMS);
1298
1299         tvnorm = &bttv_tvnorms[norm];
1300
1301         if (!memcmp(&bttv_tvnorms[btv->tvnorm].cropcap, &tvnorm->cropcap,
1302                     sizeof (tvnorm->cropcap))) {
1303                 bttv_crop_reset(&btv->crop[0], norm);
1304                 btv->crop[1] = btv->crop[0]; /* current = default */
1305
1306                 if (0 == (btv->resources & VIDEO_RESOURCES)) {
1307                         btv->crop_start = tvnorm->cropcap.bounds.top
1308                                 + tvnorm->cropcap.bounds.height;
1309                 }
1310         }
1311
1312         btv->tvnorm = norm;
1313
1314         btwrite(tvnorm->adelay, BT848_ADELAY);
1315         btwrite(tvnorm->bdelay, BT848_BDELAY);
1316         btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1317               BT848_IFORM);
1318         btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1319         btwrite(1, BT848_VBI_PACK_DEL);
1320         bt848A_set_timing(btv);
1321
1322         switch (btv->c.type) {
1323         case BTTV_BOARD_VOODOOTV_FM:
1324         case BTTV_BOARD_VOODOOTV_200:
1325                 bttv_tda9880_setnorm(btv, gpio_read());
1326                 break;
1327         }
1328         id = tvnorm->v4l2_id;
1329         bttv_call_all(btv, core, s_std, id);
1330
1331         return 0;
1332 }
1333
1334 /* Call with btv->lock down. */
1335 static void
1336 set_input(struct bttv *btv, unsigned int input, unsigned int norm)
1337 {
1338         unsigned long flags;
1339
1340         btv->input = input;
1341         if (irq_iswitch) {
1342                 spin_lock_irqsave(&btv->s_lock,flags);
1343                 if (btv->curr.frame_irq) {
1344                         /* active capture -> delayed input switch */
1345                         btv->new_input = input;
1346                 } else {
1347                         video_mux(btv,input);
1348                 }
1349                 spin_unlock_irqrestore(&btv->s_lock,flags);
1350         } else {
1351                 video_mux(btv,input);
1352         }
1353         audio_input(btv, (btv->tuner_type != TUNER_ABSENT && input == 0) ?
1354                          TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN);
1355         set_tvnorm(btv, norm);
1356 }
1357
1358 static void init_irqreg(struct bttv *btv)
1359 {
1360         /* clear status */
1361         btwrite(0xfffffUL, BT848_INT_STAT);
1362
1363         if (bttv_tvcards[btv->c.type].no_video) {
1364                 /* i2c only */
1365                 btwrite(BT848_INT_I2CDONE,
1366                         BT848_INT_MASK);
1367         } else {
1368                 /* full video */
1369                 btwrite((btv->triton1)  |
1370                         (btv->gpioirq ? BT848_INT_GPINT : 0) |
1371                         BT848_INT_SCERR |
1372                         (fdsr ? BT848_INT_FDSR : 0) |
1373                         BT848_INT_RISCI | BT848_INT_OCERR |
1374                         BT848_INT_FMTCHG|BT848_INT_HLOCK|
1375                         BT848_INT_I2CDONE,
1376                         BT848_INT_MASK);
1377         }
1378 }
1379
1380 static void init_bt848(struct bttv *btv)
1381 {
1382         int val;
1383
1384         if (bttv_tvcards[btv->c.type].no_video) {
1385                 /* very basic init only */
1386                 init_irqreg(btv);
1387                 return;
1388         }
1389
1390         btwrite(0x00, BT848_CAP_CTL);
1391         btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1392         btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1393
1394         /* set planar and packed mode trigger points and         */
1395         /* set rising edge of inverted GPINTR pin as irq trigger */
1396         btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1397                 BT848_GPIO_DMA_CTL_PLTP1_16|
1398                 BT848_GPIO_DMA_CTL_PLTP23_16|
1399                 BT848_GPIO_DMA_CTL_GPINTC|
1400                 BT848_GPIO_DMA_CTL_GPINTI,
1401                 BT848_GPIO_DMA_CTL);
1402
1403         val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1404         btwrite(val, BT848_E_SCLOOP);
1405         btwrite(val, BT848_O_SCLOOP);
1406
1407         btwrite(0x20, BT848_E_VSCALE_HI);
1408         btwrite(0x20, BT848_O_VSCALE_HI);
1409         btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1410                 BT848_ADC);
1411
1412         btwrite(whitecrush_upper, BT848_WC_UP);
1413         btwrite(whitecrush_lower, BT848_WC_DOWN);
1414
1415         if (btv->opt_lumafilter) {
1416                 btwrite(0, BT848_E_CONTROL);
1417                 btwrite(0, BT848_O_CONTROL);
1418         } else {
1419                 btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1420                 btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1421         }
1422
1423         bt848_bright(btv,   btv->bright);
1424         bt848_hue(btv,      btv->hue);
1425         bt848_contrast(btv, btv->contrast);
1426         bt848_sat(btv,      btv->saturation);
1427
1428         /* interrupt */
1429         init_irqreg(btv);
1430 }
1431
1432 static void bttv_reinit_bt848(struct bttv *btv)
1433 {
1434         unsigned long flags;
1435
1436         if (bttv_verbose)
1437                 printk(KERN_INFO "bttv%d: reset, reinitialize\n",btv->c.nr);
1438         spin_lock_irqsave(&btv->s_lock,flags);
1439         btv->errors=0;
1440         bttv_set_dma(btv,0);
1441         spin_unlock_irqrestore(&btv->s_lock,flags);
1442
1443         init_bt848(btv);
1444         btv->pll.pll_current = -1;
1445         set_input(btv, btv->input, btv->tvnorm);
1446 }
1447
1448 static int bttv_g_ctrl(struct file *file, void *priv,
1449                                         struct v4l2_control *c)
1450 {
1451         struct bttv_fh *fh = priv;
1452         struct bttv *btv = fh->btv;
1453
1454         switch (c->id) {
1455         case V4L2_CID_BRIGHTNESS:
1456                 c->value = btv->bright;
1457                 break;
1458         case V4L2_CID_HUE:
1459                 c->value = btv->hue;
1460                 break;
1461         case V4L2_CID_CONTRAST:
1462                 c->value = btv->contrast;
1463                 break;
1464         case V4L2_CID_SATURATION:
1465                 c->value = btv->saturation;
1466                 break;
1467
1468         case V4L2_CID_AUDIO_MUTE:
1469         case V4L2_CID_AUDIO_VOLUME:
1470         case V4L2_CID_AUDIO_BALANCE:
1471         case V4L2_CID_AUDIO_BASS:
1472         case V4L2_CID_AUDIO_TREBLE:
1473                 bttv_call_all(btv, core, g_ctrl, c);
1474                 break;
1475
1476         case V4L2_CID_PRIVATE_CHROMA_AGC:
1477                 c->value = btv->opt_chroma_agc;
1478                 break;
1479         case V4L2_CID_PRIVATE_COMBFILTER:
1480                 c->value = btv->opt_combfilter;
1481                 break;
1482         case V4L2_CID_PRIVATE_LUMAFILTER:
1483                 c->value = btv->opt_lumafilter;
1484                 break;
1485         case V4L2_CID_PRIVATE_AUTOMUTE:
1486                 c->value = btv->opt_automute;
1487                 break;
1488         case V4L2_CID_PRIVATE_AGC_CRUSH:
1489                 c->value = btv->opt_adc_crush;
1490                 break;
1491         case V4L2_CID_PRIVATE_VCR_HACK:
1492                 c->value = btv->opt_vcr_hack;
1493                 break;
1494         case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1495                 c->value = btv->opt_whitecrush_upper;
1496                 break;
1497         case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1498                 c->value = btv->opt_whitecrush_lower;
1499                 break;
1500         case V4L2_CID_PRIVATE_UV_RATIO:
1501                 c->value = btv->opt_uv_ratio;
1502                 break;
1503         case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1504                 c->value = btv->opt_full_luma_range;
1505                 break;
1506         case V4L2_CID_PRIVATE_CORING:
1507                 c->value = btv->opt_coring;
1508                 break;
1509         default:
1510                 return -EINVAL;
1511         }
1512         return 0;
1513 }
1514
1515 static int bttv_s_ctrl(struct file *file, void *f,
1516                                         struct v4l2_control *c)
1517 {
1518         int err;
1519         int val;
1520         struct bttv_fh *fh = f;
1521         struct bttv *btv = fh->btv;
1522
1523         err = v4l2_prio_check(&btv->prio, &fh->prio);
1524         if (0 != err)
1525                 return err;
1526
1527         switch (c->id) {
1528         case V4L2_CID_BRIGHTNESS:
1529                 bt848_bright(btv, c->value);
1530                 break;
1531         case V4L2_CID_HUE:
1532                 bt848_hue(btv, c->value);
1533                 break;
1534         case V4L2_CID_CONTRAST:
1535                 bt848_contrast(btv, c->value);
1536                 break;
1537         case V4L2_CID_SATURATION:
1538                 bt848_sat(btv, c->value);
1539                 break;
1540         case V4L2_CID_AUDIO_MUTE:
1541                 audio_mute(btv, c->value);
1542                 /* fall through */
1543         case V4L2_CID_AUDIO_VOLUME:
1544                 if (btv->volume_gpio)
1545                         btv->volume_gpio(btv, c->value);
1546
1547                 bttv_call_all(btv, core, s_ctrl, c);
1548                 break;
1549         case V4L2_CID_AUDIO_BALANCE:
1550         case V4L2_CID_AUDIO_BASS:
1551         case V4L2_CID_AUDIO_TREBLE:
1552                 bttv_call_all(btv, core, s_ctrl, c);
1553                 break;
1554
1555         case V4L2_CID_PRIVATE_CHROMA_AGC:
1556                 btv->opt_chroma_agc = c->value;
1557                 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1558                 btwrite(val, BT848_E_SCLOOP);
1559                 btwrite(val, BT848_O_SCLOOP);
1560                 break;
1561         case V4L2_CID_PRIVATE_COMBFILTER:
1562                 btv->opt_combfilter = c->value;
1563                 break;
1564         case V4L2_CID_PRIVATE_LUMAFILTER:
1565                 btv->opt_lumafilter = c->value;
1566                 if (btv->opt_lumafilter) {
1567                         btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1568                         btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1569                 } else {
1570                         btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1571                         btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1572                 }
1573                 break;
1574         case V4L2_CID_PRIVATE_AUTOMUTE:
1575                 btv->opt_automute = c->value;
1576                 break;
1577         case V4L2_CID_PRIVATE_AGC_CRUSH:
1578                 btv->opt_adc_crush = c->value;
1579                 btwrite(BT848_ADC_RESERVED |
1580                                 (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1581                                 BT848_ADC);
1582                 break;
1583         case V4L2_CID_PRIVATE_VCR_HACK:
1584                 btv->opt_vcr_hack = c->value;
1585                 break;
1586         case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1587                 btv->opt_whitecrush_upper = c->value;
1588                 btwrite(c->value, BT848_WC_UP);
1589                 break;
1590         case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1591                 btv->opt_whitecrush_lower = c->value;
1592                 btwrite(c->value, BT848_WC_DOWN);
1593                 break;
1594         case V4L2_CID_PRIVATE_UV_RATIO:
1595                 btv->opt_uv_ratio = c->value;
1596                 bt848_sat(btv, btv->saturation);
1597                 break;
1598         case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1599                 btv->opt_full_luma_range = c->value;
1600                 btaor((c->value<<7), ~BT848_OFORM_RANGE, BT848_OFORM);
1601                 break;
1602         case V4L2_CID_PRIVATE_CORING:
1603                 btv->opt_coring = c->value;
1604                 btaor((c->value<<5), ~BT848_OFORM_CORE32, BT848_OFORM);
1605                 break;
1606         default:
1607                 return -EINVAL;
1608         }
1609         return 0;
1610 }
1611
1612 /* ----------------------------------------------------------------------- */
1613
1614 void bttv_gpio_tracking(struct bttv *btv, char *comment)
1615 {
1616         unsigned int outbits, data;
1617         outbits = btread(BT848_GPIO_OUT_EN);
1618         data    = btread(BT848_GPIO_DATA);
1619         printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1620                btv->c.nr,outbits,data & outbits, data & ~outbits, comment);
1621 }
1622
1623 static void bttv_field_count(struct bttv *btv)
1624 {
1625         int need_count = 0;
1626
1627         if (btv->users)
1628                 need_count++;
1629
1630         if (need_count) {
1631                 /* start field counter */
1632                 btor(BT848_INT_VSYNC,BT848_INT_MASK);
1633         } else {
1634                 /* stop field counter */
1635                 btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1636                 btv->field_count = 0;
1637         }
1638 }
1639
1640 static const struct bttv_format*
1641 format_by_fourcc(int fourcc)
1642 {
1643         unsigned int i;
1644
1645         for (i = 0; i < FORMATS; i++) {
1646                 if (-1 == formats[i].fourcc)
1647                         continue;
1648                 if (formats[i].fourcc == fourcc)
1649                         return formats+i;
1650         }
1651         return NULL;
1652 }
1653
1654 /* ----------------------------------------------------------------------- */
1655 /* misc helpers                                                            */
1656
1657 static int
1658 bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1659                     struct bttv_buffer *new)
1660 {
1661         struct bttv_buffer *old;
1662         unsigned long flags;
1663         int retval = 0;
1664
1665         dprintk("switch_overlay: enter [new=%p]\n",new);
1666         if (new)
1667                 new->vb.state = VIDEOBUF_DONE;
1668         spin_lock_irqsave(&btv->s_lock,flags);
1669         old = btv->screen;
1670         btv->screen = new;
1671         btv->loop_irq |= 1;
1672         bttv_set_dma(btv, 0x03);
1673         spin_unlock_irqrestore(&btv->s_lock,flags);
1674         if (NULL != old) {
1675                 dprintk("switch_overlay: old=%p state is %d\n",old,old->vb.state);
1676                 bttv_dma_free(&fh->cap,btv, old);
1677                 kfree(old);
1678         }
1679         if (NULL == new)
1680                 free_btres(btv,fh,RESOURCE_OVERLAY);
1681         dprintk("switch_overlay: done\n");
1682         return retval;
1683 }
1684
1685 /* ----------------------------------------------------------------------- */
1686 /* video4linux (1) interface                                               */
1687
1688 static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1689                                struct bttv_buffer *buf,
1690                                const struct bttv_format *fmt,
1691                                unsigned int width, unsigned int height,
1692                                enum v4l2_field field)
1693 {
1694         struct bttv_fh *fh = q->priv_data;
1695         int redo_dma_risc = 0;
1696         struct bttv_crop c;
1697         int norm;
1698         int rc;
1699
1700         /* check settings */
1701         if (NULL == fmt)
1702                 return -EINVAL;
1703         if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1704                 width  = RAW_BPL;
1705                 height = RAW_LINES*2;
1706                 if (width*height > buf->vb.bsize)
1707                         return -EINVAL;
1708                 buf->vb.size = buf->vb.bsize;
1709
1710                 /* Make sure tvnorm and vbi_end remain consistent
1711                    until we're done. */
1712                 mutex_lock(&btv->lock);
1713
1714                 norm = btv->tvnorm;
1715
1716                 /* In this mode capturing always starts at defrect.top
1717                    (default VDELAY), ignoring cropping parameters. */
1718                 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
1719                         mutex_unlock(&btv->lock);
1720                         return -EINVAL;
1721                 }
1722
1723                 mutex_unlock(&btv->lock);
1724
1725                 c.rect = bttv_tvnorms[norm].cropcap.defrect;
1726         } else {
1727                 mutex_lock(&btv->lock);
1728
1729                 norm = btv->tvnorm;
1730                 c = btv->crop[!!fh->do_crop];
1731
1732                 mutex_unlock(&btv->lock);
1733
1734                 if (width < c.min_scaled_width ||
1735                     width > c.max_scaled_width ||
1736                     height < c.min_scaled_height)
1737                         return -EINVAL;
1738
1739                 switch (field) {
1740                 case V4L2_FIELD_TOP:
1741                 case V4L2_FIELD_BOTTOM:
1742                 case V4L2_FIELD_ALTERNATE:
1743                         /* btv->crop counts frame lines. Max. scale
1744                            factor is 16:1 for frames, 8:1 for fields. */
1745                         if (height * 2 > c.max_scaled_height)
1746                                 return -EINVAL;
1747                         break;
1748
1749                 default:
1750                         if (height > c.max_scaled_height)
1751                                 return -EINVAL;
1752                         break;
1753                 }
1754
1755                 buf->vb.size = (width * height * fmt->depth) >> 3;
1756                 if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
1757                         return -EINVAL;
1758         }
1759
1760         /* alloc + fill struct bttv_buffer (if changed) */
1761         if (buf->vb.width != width || buf->vb.height != height ||
1762             buf->vb.field != field ||
1763             buf->tvnorm != norm || buf->fmt != fmt ||
1764             buf->crop.top != c.rect.top ||
1765             buf->crop.left != c.rect.left ||
1766             buf->crop.width != c.rect.width ||
1767             buf->crop.height != c.rect.height) {
1768                 buf->vb.width  = width;
1769                 buf->vb.height = height;
1770                 buf->vb.field  = field;
1771                 buf->tvnorm    = norm;
1772                 buf->fmt       = fmt;
1773                 buf->crop      = c.rect;
1774                 redo_dma_risc = 1;
1775         }
1776
1777         /* alloc risc memory */
1778         if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1779                 redo_dma_risc = 1;
1780                 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
1781                         goto fail;
1782         }
1783
1784         if (redo_dma_risc)
1785                 if (0 != (rc = bttv_buffer_risc(btv,buf)))
1786                         goto fail;
1787
1788         buf->vb.state = VIDEOBUF_PREPARED;
1789         return 0;
1790
1791  fail:
1792         bttv_dma_free(q,btv,buf);
1793         return rc;
1794 }
1795
1796 static int
1797 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1798 {
1799         struct bttv_fh *fh = q->priv_data;
1800
1801         *size = fh->fmt->depth*fh->width*fh->height >> 3;
1802         if (0 == *count)
1803                 *count = gbuffers;
1804         while (*size * *count > gbuffers * gbufsize)
1805                 (*count)--;
1806         return 0;
1807 }
1808
1809 static int
1810 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1811                enum v4l2_field field)
1812 {
1813         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1814         struct bttv_fh *fh = q->priv_data;
1815
1816         return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
1817                                    fh->width, fh->height, field);
1818 }
1819
1820 static void
1821 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1822 {
1823         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1824         struct bttv_fh *fh = q->priv_data;
1825         struct bttv    *btv = fh->btv;
1826
1827         buf->vb.state = VIDEOBUF_QUEUED;
1828         list_add_tail(&buf->vb.queue,&btv->capture);
1829         if (!btv->curr.frame_irq) {
1830                 btv->loop_irq |= 1;
1831                 bttv_set_dma(btv, 0x03);
1832         }
1833 }
1834
1835 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1836 {
1837         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1838         struct bttv_fh *fh = q->priv_data;
1839
1840         bttv_dma_free(q,fh->btv,buf);
1841 }
1842
1843 static struct videobuf_queue_ops bttv_video_qops = {
1844         .buf_setup    = buffer_setup,
1845         .buf_prepare  = buffer_prepare,
1846         .buf_queue    = buffer_queue,
1847         .buf_release  = buffer_release,
1848 };
1849
1850 static int bttv_s_std(struct file *file, void *priv, v4l2_std_id *id)
1851 {
1852         struct bttv_fh *fh  = priv;
1853         struct bttv *btv = fh->btv;
1854         unsigned int i;
1855         int err;
1856
1857         err = v4l2_prio_check(&btv->prio, &fh->prio);
1858         if (0 != err)
1859                 return err;
1860
1861         for (i = 0; i < BTTV_TVNORMS; i++)
1862                 if (*id & bttv_tvnorms[i].v4l2_id)
1863                         break;
1864         if (i == BTTV_TVNORMS)
1865                 return -EINVAL;
1866
1867         mutex_lock(&btv->lock);
1868         set_tvnorm(btv, i);
1869         mutex_unlock(&btv->lock);
1870
1871         return 0;
1872 }
1873
1874 static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id)
1875 {
1876         struct bttv_fh *fh = f;
1877         struct bttv *btv = fh->btv;
1878
1879         if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1880                 *id = V4L2_STD_625_50;
1881         else
1882                 *id = V4L2_STD_525_60;
1883         return 0;
1884 }
1885
1886 static int bttv_enum_input(struct file *file, void *priv,
1887                                         struct v4l2_input *i)
1888 {
1889         struct bttv_fh *fh = priv;
1890         struct bttv *btv = fh->btv;
1891         int n;
1892
1893         if (i->index >= bttv_tvcards[btv->c.type].video_inputs)
1894                 return -EINVAL;
1895
1896         i->type     = V4L2_INPUT_TYPE_CAMERA;
1897         i->audioset = 1;
1898
1899         if (btv->tuner_type != TUNER_ABSENT && i->index == 0) {
1900                 sprintf(i->name, "Television");
1901                 i->type  = V4L2_INPUT_TYPE_TUNER;
1902                 i->tuner = 0;
1903         } else if (i->index == btv->svhs) {
1904                 sprintf(i->name, "S-Video");
1905         } else {
1906                 sprintf(i->name, "Composite%d", i->index);
1907         }
1908
1909         if (i->index == btv->input) {
1910                 __u32 dstatus = btread(BT848_DSTATUS);
1911                 if (0 == (dstatus & BT848_DSTATUS_PRES))
1912                         i->status |= V4L2_IN_ST_NO_SIGNAL;
1913                 if (0 == (dstatus & BT848_DSTATUS_HLOC))
1914                         i->status |= V4L2_IN_ST_NO_H_LOCK;
1915         }
1916
1917         for (n = 0; n < BTTV_TVNORMS; n++)
1918                 i->std |= bttv_tvnorms[n].v4l2_id;
1919
1920         return 0;
1921 }
1922
1923 static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
1924 {
1925         struct bttv_fh *fh = priv;
1926         struct bttv *btv = fh->btv;
1927
1928         *i = btv->input;
1929         return 0;
1930 }
1931
1932 static int bttv_s_input(struct file *file, void *priv, unsigned int i)
1933 {
1934         struct bttv_fh *fh  = priv;
1935         struct bttv *btv = fh->btv;
1936
1937         int err;
1938
1939         err = v4l2_prio_check(&btv->prio, &fh->prio);
1940         if (0 != err)
1941                 return err;
1942
1943         if (i > bttv_tvcards[btv->c.type].video_inputs)
1944                 return -EINVAL;
1945
1946         mutex_lock(&btv->lock);
1947         set_input(btv, i, btv->tvnorm);
1948         mutex_unlock(&btv->lock);
1949         return 0;
1950 }
1951
1952 static int bttv_s_tuner(struct file *file, void *priv,
1953                                         struct v4l2_tuner *t)
1954 {
1955         struct bttv_fh *fh  = priv;
1956         struct bttv *btv = fh->btv;
1957         int err;
1958
1959         err = v4l2_prio_check(&btv->prio, &fh->prio);
1960         if (0 != err)
1961                 return err;
1962
1963         if (btv->tuner_type == TUNER_ABSENT)
1964                 return -EINVAL;
1965
1966         if (0 != t->index)
1967                 return -EINVAL;
1968
1969         mutex_lock(&btv->lock);
1970         bttv_call_all(btv, tuner, s_tuner, t);
1971
1972         if (btv->audio_mode_gpio)
1973                 btv->audio_mode_gpio(btv, t, 1);
1974
1975         mutex_unlock(&btv->lock);
1976
1977         return 0;
1978 }
1979
1980 static int bttv_g_frequency(struct file *file, void *priv,
1981                                         struct v4l2_frequency *f)
1982 {
1983         struct bttv_fh *fh  = priv;
1984         struct bttv *btv = fh->btv;
1985         int err;
1986
1987         err = v4l2_prio_check(&btv->prio, &fh->prio);
1988         if (0 != err)
1989                 return err;
1990
1991         f->type = btv->radio_user ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1992         f->frequency = btv->freq;
1993
1994         return 0;
1995 }
1996
1997 static int bttv_s_frequency(struct file *file, void *priv,
1998                                         struct v4l2_frequency *f)
1999 {
2000         struct bttv_fh *fh  = priv;
2001         struct bttv *btv = fh->btv;
2002         int err;
2003
2004         err = v4l2_prio_check(&btv->prio, &fh->prio);
2005         if (0 != err)
2006                 return err;
2007
2008         if (unlikely(f->tuner != 0))
2009                 return -EINVAL;
2010         if (unlikely(f->type != (btv->radio_user
2011                 ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV)))
2012                 return -EINVAL;
2013         mutex_lock(&btv->lock);
2014         btv->freq = f->frequency;
2015         bttv_call_all(btv, tuner, s_frequency, f);
2016         if (btv->has_matchbox && btv->radio_user)
2017                 tea5757_set_freq(btv, btv->freq);
2018         mutex_unlock(&btv->lock);
2019         return 0;
2020 }
2021
2022 static int bttv_log_status(struct file *file, void *f)
2023 {
2024         struct bttv_fh *fh  = f;
2025         struct bttv *btv = fh->btv;
2026
2027         printk(KERN_INFO "bttv%d: ========  START STATUS CARD #%d  ========\n",
2028                         btv->c.nr, btv->c.nr);
2029         bttv_call_all(btv, core, log_status);
2030         printk(KERN_INFO "bttv%d: ========  END STATUS CARD   #%d  ========\n",
2031                         btv->c.nr, btv->c.nr);
2032         return 0;
2033 }
2034
2035 #ifdef CONFIG_VIDEO_ADV_DEBUG
2036 static int bttv_g_register(struct file *file, void *f,
2037                                         struct v4l2_dbg_register *reg)
2038 {
2039         struct bttv_fh *fh = f;
2040         struct bttv *btv = fh->btv;
2041
2042         if (!capable(CAP_SYS_ADMIN))
2043                 return -EPERM;
2044
2045         if (!v4l2_chip_match_host(&reg->match))
2046                 return -EINVAL;
2047
2048         /* bt848 has a 12-bit register space */
2049         reg->reg &= 0xfff;
2050         reg->val = btread(reg->reg);
2051         reg->size = 1;
2052
2053         return 0;
2054 }
2055
2056 static int bttv_s_register(struct file *file, void *f,
2057                                         struct v4l2_dbg_register *reg)
2058 {
2059         struct bttv_fh *fh = f;
2060         struct bttv *btv = fh->btv;
2061
2062         if (!capable(CAP_SYS_ADMIN))
2063                 return -EPERM;
2064
2065         if (!v4l2_chip_match_host(&reg->match))
2066                 return -EINVAL;
2067
2068         /* bt848 has a 12-bit register space */
2069         reg->reg &= 0xfff;
2070         btwrite(reg->val, reg->reg);
2071
2072         return 0;
2073 }
2074 #endif
2075
2076 /* Given cropping boundaries b and the scaled width and height of a
2077    single field or frame, which must not exceed hardware limits, this
2078    function adjusts the cropping parameters c. */
2079 static void
2080 bttv_crop_adjust        (struct bttv_crop *             c,
2081                          const struct v4l2_rect *       b,
2082                          __s32                          width,
2083                          __s32                          height,
2084                          enum v4l2_field                field)
2085 {
2086         __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
2087         __s32 max_left;
2088         __s32 max_top;
2089
2090         if (width < c->min_scaled_width) {
2091                 /* Max. hor. scale factor 16:1. */
2092                 c->rect.width = width * 16;
2093         } else if (width > c->max_scaled_width) {
2094                 /* Min. hor. scale factor 1:1. */
2095                 c->rect.width = width;
2096
2097                 max_left = b->left + b->width - width;
2098                 max_left = min(max_left, (__s32) MAX_HDELAY);
2099                 if (c->rect.left > max_left)
2100                         c->rect.left = max_left;
2101         }
2102
2103         if (height < c->min_scaled_height) {
2104                 /* Max. vert. scale factor 16:1, single fields 8:1. */
2105                 c->rect.height = height * 16;
2106         } else if (frame_height > c->max_scaled_height) {
2107                 /* Min. vert. scale factor 1:1.
2108                    Top and height count field lines times two. */
2109                 c->rect.height = (frame_height + 1) & ~1;
2110
2111                 max_top = b->top + b->height - c->rect.height;
2112                 if (c->rect.top > max_top)
2113                         c->rect.top = max_top;
2114         }
2115
2116         bttv_crop_calc_limits(c);
2117 }
2118
2119 /* Returns an error if scaling to a frame or single field with the given
2120    width and height is not possible with the current cropping parameters
2121    and width aligned according to width_mask. If adjust_size is TRUE the
2122    function may adjust the width and/or height instead, rounding width
2123    to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
2124    also adjust the current cropping parameters to get closer to the
2125    desired image size. */
2126 static int
2127 limit_scaled_size       (struct bttv_fh *               fh,
2128                          __s32 *                        width,
2129                          __s32 *                        height,
2130                          enum v4l2_field                field,
2131                          unsigned int                   width_mask,
2132                          unsigned int                   width_bias,
2133                          int                            adjust_size,
2134                          int                            adjust_crop)
2135 {
2136         struct bttv *btv = fh->btv;
2137         const struct v4l2_rect *b;
2138         struct bttv_crop *c;
2139         __s32 min_width;
2140         __s32 min_height;
2141         __s32 max_width;
2142         __s32 max_height;
2143         int rc;
2144
2145         BUG_ON((int) width_mask >= 0 ||
2146                width_bias >= (unsigned int) -width_mask);
2147
2148         /* Make sure tvnorm, vbi_end and the current cropping parameters
2149            remain consistent until we're done. */
2150         mutex_lock(&btv->lock);
2151
2152         b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2153
2154         /* Do crop - use current, don't - use default parameters. */
2155         c = &btv->crop[!!fh->do_crop];
2156
2157         if (fh->do_crop
2158             && adjust_size
2159             && adjust_crop
2160             && !locked_btres(btv, VIDEO_RESOURCES)) {
2161                 min_width = 48;
2162                 min_height = 32;
2163
2164                 /* We cannot scale up. When the scaled image is larger
2165                    than crop.rect we adjust the crop.rect as required
2166                    by the V4L2 spec, hence cropcap.bounds are our limit. */
2167                 max_width = min(b->width, (__s32) MAX_HACTIVE);
2168                 max_height = b->height;
2169
2170                 /* We cannot capture the same line as video and VBI data.
2171                    Note btv->vbi_end is really a minimum, see
2172                    bttv_vbi_try_fmt(). */
2173                 if (btv->vbi_end > b->top) {
2174                         max_height -= btv->vbi_end - b->top;
2175                         rc = -EBUSY;
2176                         if (min_height > max_height)
2177                                 goto fail;
2178                 }
2179         } else {
2180                 rc = -EBUSY;
2181                 if (btv->vbi_end > c->rect.top)
2182                         goto fail;
2183
2184                 min_width  = c->min_scaled_width;
2185                 min_height = c->min_scaled_height;
2186                 max_width  = c->max_scaled_width;
2187                 max_height = c->max_scaled_height;
2188
2189                 adjust_crop = 0;
2190         }
2191
2192         min_width = (min_width - width_mask - 1) & width_mask;
2193         max_width = max_width & width_mask;
2194
2195         /* Max. scale factor is 16:1 for frames, 8:1 for fields. */
2196         min_height = min_height;
2197         /* Min. scale factor is 1:1. */
2198         max_height >>= !V4L2_FIELD_HAS_BOTH(field);
2199
2200         if (adjust_size) {
2201                 *width = clamp(*width, min_width, max_width);
2202                 *height = clamp(*height, min_height, max_height);
2203
2204                 /* Round after clamping to avoid overflow. */
2205                 *width = (*width + width_bias) & width_mask;
2206
2207                 if (adjust_crop) {
2208                         bttv_crop_adjust(c, b, *width, *height, field);
2209
2210                         if (btv->vbi_end > c->rect.top) {
2211                                 /* Move the crop window out of the way. */
2212                                 c->rect.top = btv->vbi_end;
2213                         }
2214                 }
2215         } else {
2216                 rc = -EINVAL;
2217                 if (*width  < min_width ||
2218                     *height < min_height ||
2219                     *width  > max_width ||
2220                     *height > max_height ||
2221                     0 != (*width & ~width_mask))
2222                         goto fail;
2223         }
2224
2225         rc = 0; /* success */
2226
2227  fail:
2228         mutex_unlock(&btv->lock);
2229
2230         return rc;
2231 }
2232
2233 /* Returns an error if the given overlay window dimensions are not
2234    possible with the current cropping parameters. If adjust_size is
2235    TRUE the function may adjust the window width and/or height
2236    instead, however it always rounds the horizontal position and
2237    width as btcx_align() does. If adjust_crop is TRUE the function
2238    may also adjust the current cropping parameters to get closer
2239    to the desired window size. */
2240 static int
2241 verify_window           (struct bttv_fh *               fh,
2242                          struct v4l2_window *           win,
2243                          int                            adjust_size,
2244                          int                            adjust_crop)
2245 {
2246         enum v4l2_field field;
2247         unsigned int width_mask;
2248         int rc;
2249
2250         if (win->w.width  < 48 || win->w.height < 32)
2251                 return -EINVAL;
2252         if (win->clipcount > 2048)
2253                 return -EINVAL;
2254
2255         field = win->field;
2256
2257         if (V4L2_FIELD_ANY == field) {
2258                 __s32 height2;
2259
2260                 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2261                 field = (win->w.height > height2)
2262                         ? V4L2_FIELD_INTERLACED
2263                         : V4L2_FIELD_TOP;
2264         }
2265         switch (field) {
2266         case V4L2_FIELD_TOP:
2267         case V4L2_FIELD_BOTTOM:
2268         case V4L2_FIELD_INTERLACED:
2269                 break;
2270         default:
2271                 return -EINVAL;
2272         }
2273
2274         /* 4-byte alignment. */
2275         if (NULL == fh->ovfmt)
2276                 return -EINVAL;
2277         width_mask = ~0;
2278         switch (fh->ovfmt->depth) {
2279         case 8:
2280         case 24:
2281                 width_mask = ~3;
2282                 break;
2283         case 16:
2284                 width_mask = ~1;
2285                 break;
2286         case 32:
2287                 break;
2288         default:
2289                 BUG();
2290         }
2291
2292         win->w.width -= win->w.left & ~width_mask;
2293         win->w.left = (win->w.left - width_mask - 1) & width_mask;
2294
2295         rc = limit_scaled_size(fh, &win->w.width, &win->w.height,
2296                                field, width_mask,
2297                                /* width_bias: round down */ 0,
2298                                adjust_size, adjust_crop);
2299         if (0 != rc)
2300                 return rc;
2301
2302         win->field = field;
2303         return 0;
2304 }
2305
2306 static int setup_window(struct bttv_fh *fh, struct bttv *btv,
2307                         struct v4l2_window *win, int fixup)
2308 {
2309         struct v4l2_clip *clips = NULL;
2310         int n,size,retval = 0;
2311
2312         if (NULL == fh->ovfmt)
2313                 return -EINVAL;
2314         if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2315                 return -EINVAL;
2316         retval = verify_window(fh, win,
2317                                /* adjust_size */ fixup,
2318                                /* adjust_crop */ fixup);
2319         if (0 != retval)
2320                 return retval;
2321
2322         /* copy clips  --  luckily v4l1 + v4l2 are binary
2323            compatible here ...*/
2324         n = win->clipcount;
2325         size = sizeof(*clips)*(n+4);
2326         clips = kmalloc(size,GFP_KERNEL);
2327         if (NULL == clips)
2328                 return -ENOMEM;
2329         if (n > 0) {
2330                 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2331                         kfree(clips);
2332                         return -EFAULT;
2333                 }
2334         }
2335         /* clip against screen */
2336         if (NULL != btv->fbuf.base)
2337                 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2338                                       &win->w, clips, n);
2339         btcx_sort_clips(clips,n);
2340
2341         /* 4-byte alignments */
2342         switch (fh->ovfmt->depth) {
2343         case 8:
2344         case 24:
2345                 btcx_align(&win->w, clips, n, 3);
2346                 break;
2347         case 16:
2348                 btcx_align(&win->w, clips, n, 1);
2349                 break;
2350         case 32:
2351                 /* no alignment fixups needed */
2352                 break;
2353         default:
2354                 BUG();
2355         }
2356
2357         mutex_lock(&fh->cap.vb_lock);
2358         kfree(fh->ov.clips);
2359         fh->ov.clips    = clips;
2360         fh->ov.nclips   = n;
2361
2362         fh->ov.w        = win->w;
2363         fh->ov.field    = win->field;
2364         fh->ov.setup_ok = 1;
2365         btv->init.ov.w.width   = win->w.width;
2366         btv->init.ov.w.height  = win->w.height;
2367         btv->init.ov.field     = win->field;
2368
2369         /* update overlay if needed */
2370         retval = 0;
2371         if (check_btres(fh, RESOURCE_OVERLAY)) {
2372                 struct bttv_buffer *new;
2373
2374                 new = videobuf_sg_alloc(sizeof(*new));
2375                 new->crop = btv->crop[!!fh->do_crop].rect;
2376                 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2377                 retval = bttv_switch_overlay(btv,fh,new);
2378         }
2379         mutex_unlock(&fh->cap.vb_lock);
2380         return retval;
2381 }
2382
2383 /* ----------------------------------------------------------------------- */
2384
2385 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2386 {
2387         struct videobuf_queue* q = NULL;
2388
2389         switch (fh->type) {
2390         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2391                 q = &fh->cap;
2392                 break;
2393         case V4L2_BUF_TYPE_VBI_CAPTURE:
2394                 q = &fh->vbi;
2395                 break;
2396         default:
2397                 BUG();
2398         }
2399         return q;
2400 }
2401
2402 static int bttv_resource(struct bttv_fh *fh)
2403 {
2404         int res = 0;
2405
2406         switch (fh->type) {
2407         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2408                 res = RESOURCE_VIDEO_STREAM;
2409                 break;
2410         case V4L2_BUF_TYPE_VBI_CAPTURE:
2411                 res = RESOURCE_VBI;
2412                 break;
2413         default:
2414                 BUG();
2415         }
2416         return res;
2417 }
2418
2419 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2420 {
2421         struct videobuf_queue *q = bttv_queue(fh);
2422         int res = bttv_resource(fh);
2423
2424         if (check_btres(fh,res))
2425                 return -EBUSY;
2426         if (videobuf_queue_is_busy(q))
2427                 return -EBUSY;
2428         fh->type = type;
2429         return 0;
2430 }
2431
2432 static void
2433 pix_format_set_size     (struct v4l2_pix_format *       f,
2434                          const struct bttv_format *     fmt,
2435                          unsigned int                   width,
2436                          unsigned int                   height)
2437 {
2438         f->width = width;
2439         f->height = height;
2440
2441         if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2442                 f->bytesperline = width; /* Y plane */
2443                 f->sizeimage = (width * height * fmt->depth) >> 3;
2444         } else {
2445                 f->bytesperline = (width * fmt->depth) >> 3;
2446                 f->sizeimage = height * f->bytesperline;
2447         }
2448 }
2449
2450 static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
2451                                         struct v4l2_format *f)
2452 {
2453         struct bttv_fh *fh  = priv;
2454
2455         pix_format_set_size(&f->fmt.pix, fh->fmt,
2456                                 fh->width, fh->height);
2457         f->fmt.pix.field        = fh->cap.field;
2458         f->fmt.pix.pixelformat  = fh->fmt->fourcc;
2459
2460         return 0;
2461 }
2462
2463 static int bttv_g_fmt_vid_overlay(struct file *file, void *priv,
2464                                         struct v4l2_format *f)
2465 {
2466         struct bttv_fh *fh  = priv;
2467
2468         f->fmt.win.w     = fh->ov.w;
2469         f->fmt.win.field = fh->ov.field;
2470
2471         return 0;
2472 }
2473
2474 static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
2475                                                 struct v4l2_format *f)
2476 {
2477         const struct bttv_format *fmt;
2478         struct bttv_fh *fh = priv;
2479         struct bttv *btv = fh->btv;
2480         enum v4l2_field field;
2481         __s32 width, height;
2482         int rc;
2483
2484         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2485         if (NULL == fmt)
2486                 return -EINVAL;
2487
2488         field = f->fmt.pix.field;
2489
2490         if (V4L2_FIELD_ANY == field) {
2491                 __s32 height2;
2492
2493                 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2494                 field = (f->fmt.pix.height > height2)
2495                         ? V4L2_FIELD_INTERLACED
2496                         : V4L2_FIELD_BOTTOM;
2497         }
2498
2499         if (V4L2_FIELD_SEQ_BT == field)
2500                 field = V4L2_FIELD_SEQ_TB;
2501
2502         switch (field) {
2503         case V4L2_FIELD_TOP:
2504         case V4L2_FIELD_BOTTOM:
2505         case V4L2_FIELD_ALTERNATE:
2506         case V4L2_FIELD_INTERLACED:
2507                 break;
2508         case V4L2_FIELD_SEQ_TB:
2509                 if (fmt->flags & FORMAT_FLAGS_PLANAR)
2510                         return -EINVAL;
2511                 break;
2512         default:
2513                 return -EINVAL;
2514         }
2515
2516         width = f->fmt.pix.width;
2517         height = f->fmt.pix.height;
2518
2519         rc = limit_scaled_size(fh, &width, &height, field,
2520                                /* width_mask: 4 pixels */ ~3,
2521                                /* width_bias: nearest */ 2,
2522                                /* adjust_size */ 1,
2523                                /* adjust_crop */ 0);
2524         if (0 != rc)
2525                 return rc;
2526
2527         /* update data for the application */
2528         f->fmt.pix.field = field;
2529         pix_format_set_size(&f->fmt.pix, fmt, width, height);
2530
2531         return 0;
2532 }
2533
2534 static int bttv_try_fmt_vid_overlay(struct file *file, void *priv,
2535                                                 struct v4l2_format *f)
2536 {
2537         struct bttv_fh *fh = priv;
2538
2539         return verify_window(fh, &f->fmt.win,
2540                         /* adjust_size */ 1,
2541                         /* adjust_crop */ 0);
2542 }
2543
2544 static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2545                                 struct v4l2_format *f)
2546 {
2547         int retval;
2548         const struct bttv_format *fmt;
2549         struct bttv_fh *fh = priv;
2550         struct bttv *btv = fh->btv;
2551         __s32 width, height;
2552         enum v4l2_field field;
2553
2554         retval = bttv_switch_type(fh, f->type);
2555         if (0 != retval)
2556                 return retval;
2557
2558         retval = bttv_try_fmt_vid_cap(file, priv, f);
2559         if (0 != retval)
2560                 return retval;
2561
2562         width = f->fmt.pix.width;
2563         height = f->fmt.pix.height;
2564         field = f->fmt.pix.field;
2565
2566         retval = limit_scaled_size(fh, &width, &height, f->fmt.pix.field,
2567                                /* width_mask: 4 pixels */ ~3,
2568                                /* width_bias: nearest */ 2,
2569                                /* adjust_size */ 1,
2570                                /* adjust_crop */ 1);
2571         if (0 != retval)
2572                 return retval;
2573
2574         f->fmt.pix.field = field;
2575
2576         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2577
2578         /* update our state informations */
2579         mutex_lock(&fh->cap.vb_lock);
2580         fh->fmt              = fmt;
2581         fh->cap.field        = f->fmt.pix.field;
2582         fh->cap.last         = V4L2_FIELD_NONE;
2583         fh->width            = f->fmt.pix.width;
2584         fh->height           = f->fmt.pix.height;
2585         btv->init.fmt        = fmt;
2586         btv->init.width      = f->fmt.pix.width;
2587         btv->init.height     = f->fmt.pix.height;
2588         mutex_unlock(&fh->cap.vb_lock);
2589
2590         return 0;
2591 }
2592
2593 static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
2594                                 struct v4l2_format *f)
2595 {
2596         struct bttv_fh *fh = priv;
2597         struct bttv *btv = fh->btv;
2598
2599         if (no_overlay > 0) {
2600                 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2601                 return -EINVAL;
2602         }
2603
2604         return setup_window(fh, btv, &f->fmt.win, 1);
2605 }
2606
2607 #ifdef CONFIG_VIDEO_V4L1_COMPAT
2608 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
2609 {
2610         int retval;
2611         unsigned int i;
2612         struct bttv_fh *fh = priv;
2613
2614         mutex_lock(&fh->cap.vb_lock);
2615         retval = __videobuf_mmap_setup(&fh->cap, gbuffers, gbufsize,
2616                                      V4L2_MEMORY_MMAP);
2617         if (retval < 0) {
2618                 mutex_unlock(&fh->cap.vb_lock);
2619                 return retval;
2620         }
2621
2622         gbuffers = retval;
2623         memset(mbuf, 0, sizeof(*mbuf));
2624         mbuf->frames = gbuffers;
2625         mbuf->size   = gbuffers * gbufsize;
2626
2627         for (i = 0; i < gbuffers; i++)
2628                 mbuf->offsets[i] = i * gbufsize;
2629
2630         mutex_unlock(&fh->cap.vb_lock);
2631         return 0;
2632 }
2633 #endif
2634
2635 static int bttv_querycap(struct file *file, void  *priv,
2636                                 struct v4l2_capability *cap)
2637 {
2638         struct bttv_fh *fh = priv;
2639         struct bttv *btv = fh->btv;
2640
2641         if (0 == v4l2)
2642                 return -EINVAL;
2643
2644         strlcpy(cap->driver, "bttv", sizeof(cap->driver));
2645         strlcpy(cap->card, btv->video_dev->name, sizeof(cap->card));
2646         snprintf(cap->bus_info, sizeof(cap->bus_info),
2647                  "PCI:%s", pci_name(btv->c.pci));
2648         cap->version = BTTV_VERSION_CODE;
2649         cap->capabilities =
2650                 V4L2_CAP_VIDEO_CAPTURE |
2651                 V4L2_CAP_VBI_CAPTURE |
2652                 V4L2_CAP_READWRITE |
2653                 V4L2_CAP_STREAMING;
2654         if (no_overlay <= 0)
2655                 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2656
2657         if (btv->tuner_type != TUNER_ABSENT)
2658                 cap->capabilities |= V4L2_CAP_TUNER;
2659         return 0;
2660 }
2661
2662 static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f)
2663 {
2664         int index = -1, i;
2665
2666         for (i = 0; i < FORMATS; i++) {
2667                 if (formats[i].fourcc != -1)
2668                         index++;
2669                 if ((unsigned int)index == f->index)
2670                         break;
2671         }
2672         if (FORMATS == i)
2673                 return -EINVAL;
2674
2675         f->pixelformat = formats[i].fourcc;
2676         strlcpy(f->description, formats[i].name, sizeof(f->description));
2677
2678         return i;
2679 }
2680
2681 static int bttv_enum_fmt_vid_cap(struct file *file, void  *priv,
2682                                 struct v4l2_fmtdesc *f)
2683 {
2684         int rc = bttv_enum_fmt_cap_ovr(f);
2685
2686         if (rc < 0)
2687                 return rc;
2688
2689         return 0;
2690 }
2691
2692 static int bttv_enum_fmt_vid_overlay(struct file *file, void  *priv,
2693                                         struct v4l2_fmtdesc *f)
2694 {
2695         int rc;
2696
2697         if (no_overlay > 0) {
2698                 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2699                 return -EINVAL;
2700         }
2701
2702         rc = bttv_enum_fmt_cap_ovr(f);
2703
2704         if (rc < 0)
2705                 return rc;
2706
2707         if (!(formats[rc].flags & FORMAT_FLAGS_PACKED))
2708                 return -EINVAL;
2709
2710         return 0;
2711 }
2712
2713 static int bttv_g_fbuf(struct file *file, void *f,
2714                                 struct v4l2_framebuffer *fb)
2715 {
2716         struct bttv_fh *fh = f;
2717         struct bttv *btv = fh->btv;
2718
2719         *fb = btv->fbuf;
2720         fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2721         if (fh->ovfmt)
2722                 fb->fmt.pixelformat  = fh->ovfmt->fourcc;
2723         return 0;
2724 }
2725
2726 static int bttv_overlay(struct file *file, void *f, unsigned int on)
2727 {
2728         struct bttv_fh *fh = f;
2729         struct bttv *btv = fh->btv;
2730         struct bttv_buffer *new;
2731         int retval;
2732
2733         if (on) {
2734                 /* verify args */
2735                 if (NULL == btv->fbuf.base)
2736                         return -EINVAL;
2737                 if (!fh->ov.setup_ok) {
2738                         dprintk("bttv%d: overlay: !setup_ok\n", btv->c.nr);
2739                         return -EINVAL;
2740                 }
2741         }
2742
2743         if (!check_alloc_btres(btv, fh, RESOURCE_OVERLAY))
2744                 return -EBUSY;
2745
2746         mutex_lock(&fh->cap.vb_lock);
2747         if (on) {
2748                 fh->ov.tvnorm = btv->tvnorm;
2749                 new = videobuf_sg_alloc(sizeof(*new));
2750                 new->crop = btv->crop[!!fh->do_crop].rect;
2751                 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2752         } else {
2753                 new = NULL;
2754         }
2755
2756         /* switch over */
2757         retval = bttv_switch_overlay(btv, fh, new);
2758         mutex_unlock(&fh->cap.vb_lock);
2759         return retval;
2760 }
2761
2762 static int bttv_s_fbuf(struct file *file, void *f,
2763                                 struct v4l2_framebuffer *fb)
2764 {
2765         struct bttv_fh *fh = f;
2766         struct bttv *btv = fh->btv;
2767         const struct bttv_format *fmt;
2768         int retval;
2769
2770         if (!capable(CAP_SYS_ADMIN) &&
2771                 !capable(CAP_SYS_RAWIO))
2772                 return -EPERM;
2773
2774         /* check args */
2775         fmt = format_by_fourcc(fb->fmt.pixelformat);
2776         if (NULL == fmt)
2777                 return -EINVAL;
2778         if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2779                 return -EINVAL;
2780
2781         retval = -EINVAL;
2782         if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2783                 __s32 width = fb->fmt.width;
2784                 __s32 height = fb->fmt.height;
2785
2786                 retval = limit_scaled_size(fh, &width, &height,
2787                                            V4L2_FIELD_INTERLACED,
2788                                            /* width_mask */ ~3,
2789                                            /* width_bias */ 2,
2790                                            /* adjust_size */ 0,
2791                                            /* adjust_crop */ 0);
2792                 if (0 != retval)
2793                         return retval;
2794         }
2795
2796         /* ok, accept it */
2797         mutex_lock(&fh->cap.vb_lock);
2798         btv->fbuf.base       = fb->base;
2799         btv->fbuf.fmt.width  = fb->fmt.width;
2800         btv->fbuf.fmt.height = fb->fmt.height;
2801         if (0 != fb->fmt.bytesperline)
2802                 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2803         else
2804                 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2805
2806         retval = 0;
2807         fh->ovfmt = fmt;
2808         btv->init.ovfmt = fmt;
2809         if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2810                 fh->ov.w.left   = 0;
2811                 fh->ov.w.top    = 0;
2812                 fh->ov.w.width  = fb->fmt.width;
2813                 fh->ov.w.height = fb->fmt.height;
2814                 btv->init.ov.w.width  = fb->fmt.width;
2815                 btv->init.ov.w.height = fb->fmt.height;
2816                         kfree(fh->ov.clips);
2817                 fh->ov.clips = NULL;
2818                 fh->ov.nclips = 0;
2819
2820                 if (check_btres(fh, RESOURCE_OVERLAY)) {
2821                         struct bttv_buffer *new;
2822
2823                         new = videobuf_sg_alloc(sizeof(*new));
2824                         new->crop = btv->crop[!!fh->do_crop].rect;
2825                         bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2826                         retval = bttv_switch_overlay(btv, fh, new);
2827                 }
2828         }
2829         mutex_unlock(&fh->cap.vb_lock);
2830         return retval;
2831 }
2832
2833 static int bttv_reqbufs(struct file *file, void *priv,
2834                                 struct v4l2_requestbuffers *p)
2835 {
2836         struct bttv_fh *fh = priv;
2837         return videobuf_reqbufs(bttv_queue(fh), p);
2838 }
2839
2840 static int bttv_querybuf(struct file *file, void *priv,
2841                                 struct v4l2_buffer *b)
2842 {
2843         struct bttv_fh *fh = priv;
2844         return videobuf_querybuf(bttv_queue(fh), b);
2845 }
2846
2847 static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2848 {
2849         struct bttv_fh *fh = priv;
2850         struct bttv *btv = fh->btv;
2851         int res = bttv_resource(fh);
2852
2853         if (!check_alloc_btres(btv, fh, res))
2854                 return -EBUSY;
2855
2856         return videobuf_qbuf(bttv_queue(fh), b);
2857 }
2858
2859 static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2860 {
2861         struct bttv_fh *fh = priv;
2862         return videobuf_dqbuf(bttv_queue(fh), b,
2863                         file->f_flags & O_NONBLOCK);
2864 }
2865
2866 static int bttv_streamon(struct file *file, void *priv,
2867                                         enum v4l2_buf_type type)
2868 {
2869         struct bttv_fh *fh = priv;
2870         struct bttv *btv = fh->btv;
2871         int res = bttv_resource(fh);
2872
2873         if (!check_alloc_btres(btv, fh, res))
2874                 return -EBUSY;
2875         return videobuf_streamon(bttv_queue(fh));
2876 }
2877
2878
2879 static int bttv_streamoff(struct file *file, void *priv,
2880                                         enum v4l2_buf_type type)
2881 {
2882         struct bttv_fh *fh = priv;
2883         struct bttv *btv = fh->btv;
2884         int retval;
2885         int res = bttv_resource(fh);
2886
2887
2888         retval = videobuf_streamoff(bttv_queue(fh));
2889         if (retval < 0)
2890                 return retval;
2891         free_btres(btv, fh, res);
2892         return 0;
2893 }
2894
2895 static int bttv_queryctrl(struct file *file, void *priv,
2896                                         struct v4l2_queryctrl *c)
2897 {
2898         struct bttv_fh *fh = priv;
2899         struct bttv *btv = fh->btv;
2900         const struct v4l2_queryctrl *ctrl;
2901
2902         if ((c->id <  V4L2_CID_BASE ||
2903              c->id >= V4L2_CID_LASTP1) &&
2904             (c->id <  V4L2_CID_PRIVATE_BASE ||
2905              c->id >= V4L2_CID_PRIVATE_LASTP1))
2906                 return -EINVAL;
2907
2908         if (!btv->volume_gpio && (c->id == V4L2_CID_AUDIO_VOLUME))
2909                 *c = no_ctl;
2910         else {
2911                 ctrl = ctrl_by_id(c->id);
2912
2913                 *c = (NULL != ctrl) ? *ctrl : no_ctl;
2914         }
2915
2916         return 0;
2917 }
2918
2919 static int bttv_g_parm(struct file *file, void *f,
2920                                 struct v4l2_streamparm *parm)
2921 {
2922         struct bttv_fh *fh = f;
2923         struct bttv *btv = fh->btv;
2924
2925         v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id,
2926                                     &parm->parm.capture.timeperframe);
2927         return 0;
2928 }
2929
2930 static int bttv_g_tuner(struct file *file, void *priv,
2931                                 struct v4l2_tuner *t)
2932 {
2933         struct bttv_fh *fh = priv;
2934         struct bttv *btv = fh->btv;
2935
2936         if (btv->tuner_type == TUNER_ABSENT)
2937                 return -EINVAL;
2938         if (0 != t->index)
2939                 return -EINVAL;
2940
2941         mutex_lock(&btv->lock);
2942         t->rxsubchans = V4L2_TUNER_SUB_MONO;
2943         bttv_call_all(btv, tuner, g_tuner, t);
2944         strcpy(t->name, "Television");
2945         t->capability = V4L2_TUNER_CAP_NORM;
2946         t->type       = V4L2_TUNER_ANALOG_TV;
2947         if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2948                 t->signal = 0xffff;
2949
2950         if (btv->audio_mode_gpio)
2951                 btv->audio_mode_gpio(btv, t, 0);
2952
2953         mutex_unlock(&btv->lock);
2954         return 0;
2955 }
2956
2957 static int bttv_g_priority(struct file *file, void *f, enum v4l2_priority *p)
2958 {
2959         struct bttv_fh *fh = f;
2960         struct bttv *btv = fh->btv;
2961
2962         *p = v4l2_prio_max(&btv->prio);
2963
2964         return 0;
2965 }
2966
2967 static int bttv_s_priority(struct file *file, void *f,
2968                                         enum v4l2_priority prio)
2969 {
2970         struct bttv_fh *fh = f;
2971         struct bttv *btv = fh->btv;
2972
2973         return v4l2_prio_change(&btv->prio, &fh->prio, prio);
2974 }
2975
2976 static int bttv_cropcap(struct file *file, void *priv,
2977                                 struct v4l2_cropcap *cap)
2978 {
2979         struct bttv_fh *fh = priv;
2980         struct bttv *btv = fh->btv;
2981
2982         if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2983             cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2984                 return -EINVAL;
2985
2986         *cap = bttv_tvnorms[btv->tvnorm].cropcap;
2987
2988         return 0;
2989 }
2990
2991 static int bttv_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
2992 {
2993         struct bttv_fh *fh = f;
2994         struct bttv *btv = fh->btv;
2995
2996         if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2997             crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2998                 return -EINVAL;
2999
3000         /* No fh->do_crop = 1; because btv->crop[1] may be
3001            inconsistent with fh->width or fh->height and apps
3002            do not expect a change here. */
3003
3004         crop->c = btv->crop[!!fh->do_crop].rect;
3005
3006         return 0;
3007 }
3008
3009 static int bttv_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
3010 {
3011         struct bttv_fh *fh = f;
3012         struct bttv *btv = fh->btv;
3013         const struct v4l2_rect *b;
3014         int retval;
3015         struct bttv_crop c;
3016         __s32 b_left;
3017         __s32 b_top;
3018         __s32 b_right;
3019         __s32 b_bottom;
3020
3021         if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3022             crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3023                 return -EINVAL;
3024
3025         retval = v4l2_prio_check(&btv->prio, &fh->prio);
3026         if (0 != retval)
3027                 return retval;
3028
3029         /* Make sure tvnorm, vbi_end and the current cropping
3030            parameters remain consistent until we're done. Note
3031            read() may change vbi_end in check_alloc_btres(). */
3032         mutex_lock(&btv->lock);
3033
3034         retval = -EBUSY;
3035
3036         if (locked_btres(fh->btv, VIDEO_RESOURCES)) {
3037                 mutex_unlock(&btv->lock);
3038                 return retval;
3039         }
3040
3041         b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
3042
3043         b_left = b->left;
3044         b_right = b_left + b->width;
3045         b_bottom = b->top + b->height;
3046
3047         b_top = max(b->top, btv->vbi_end);
3048         if (b_top + 32 >= b_bottom) {
3049                 mutex_unlock(&btv->lock);
3050                 return retval;
3051         }
3052
3053         /* Min. scaled size 48 x 32. */
3054         c.rect.left = clamp(crop->c.left, b_left, b_right - 48);
3055         c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
3056
3057         c.rect.width = clamp(crop->c.width,
3058                              48, b_right - c.rect.left);
3059
3060         c.rect.top = clamp(crop->c.top, b_top, b_bottom - 32);
3061         /* Top and height must be a multiple of two. */
3062         c.rect.top = (c.rect.top + 1) & ~1;
3063
3064         c.rect.height = clamp(crop->c.height,
3065                               32, b_bottom - c.rect.top);
3066         c.rect.height = (c.rect.height + 1) & ~1;
3067
3068         bttv_crop_calc_limits(&c);
3069
3070         btv->crop[1] = c;
3071
3072         mutex_unlock(&btv->lock);
3073
3074         fh->do_crop = 1;
3075
3076         mutex_lock(&fh->cap.vb_lock);
3077
3078         if (fh->width < c.min_scaled_width) {
3079                 fh->width = c.min_scaled_width;
3080                 btv->init.width = c.min_scaled_width;
3081         } else if (fh->width > c.max_scaled_width) {
3082                 fh->width = c.max_scaled_width;
3083                 btv->init.width = c.max_scaled_width;
3084         }
3085
3086         if (fh->height < c.min_scaled_height) {
3087                 fh->height = c.min_scaled_height;
3088                 btv->init.height = c.min_scaled_height;
3089         } else if (fh->height > c.max_scaled_height) {
3090                 fh->height = c.max_scaled_height;
3091                 btv->init.height = c.max_scaled_height;
3092         }
3093
3094         mutex_unlock(&fh->cap.vb_lock);
3095
3096         return 0;
3097 }
3098
3099 static int bttv_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
3100 {
3101         if (unlikely(a->index))
3102                 return -EINVAL;
3103
3104         strcpy(a->name, "audio");
3105         return 0;
3106 }
3107
3108 static int bttv_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
3109 {
3110         if (unlikely(a->index))
3111                 return -EINVAL;
3112
3113         return 0;
3114 }
3115
3116 static ssize_t bttv_read(struct file *file, char __user *data,
3117                          size_t count, loff_t *ppos)
3118 {
3119         struct bttv_fh *fh = file->private_data;
3120         int retval = 0;
3121
3122         if (fh->btv->errors)
3123                 bttv_reinit_bt848(fh->btv);
3124         dprintk("bttv%d: read count=%d type=%s\n",
3125                 fh->btv->c.nr,(int)count,v4l2_type_names[fh->type]);
3126
3127         switch (fh->type) {
3128         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3129                 if (!check_alloc_btres(fh->btv, fh, RESOURCE_VIDEO_READ)) {
3130                         /* VIDEO_READ in use by another fh,
3131                            or VIDEO_STREAM by any fh. */
3132                         return -EBUSY;
3133                 }
3134                 retval = videobuf_read_one(&fh->cap, data, count, ppos,
3135                                            file->f_flags & O_NONBLOCK);
3136                 free_btres(fh->btv, fh, RESOURCE_VIDEO_READ);
3137                 break;
3138         case V4L2_BUF_TYPE_VBI_CAPTURE:
3139                 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3140                         return -EBUSY;
3141                 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
3142                                               file->f_flags & O_NONBLOCK);
3143                 break;
3144         default:
3145                 BUG();
3146         }
3147         return retval;
3148 }
3149
3150 static unsigned int bttv_poll(struct file *file, poll_table *wait)
3151 {
3152         struct bttv_fh *fh = file->private_data;
3153         struct bttv_buffer *buf;
3154         enum v4l2_field field;
3155         unsigned int rc = POLLERR;
3156
3157         if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
3158                 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3159                         return POLLERR;
3160                 return videobuf_poll_stream(file, &fh->vbi, wait);
3161         }
3162
3163         if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
3164                 mutex_lock(&fh->cap.vb_lock);
3165                 /* streaming capture */
3166                 if (list_empty(&fh->cap.stream))
3167                         goto err;
3168                 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
3169         } else {
3170                 /* read() capture */
3171                 mutex_lock(&fh->cap.vb_lock);
3172                 if (NULL == fh->cap.read_buf) {
3173                         /* need to capture a new frame */
3174                         if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
3175                                 goto err;
3176                         fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize);
3177                         if (NULL == fh->cap.read_buf)
3178                                 goto err;
3179                         fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
3180                         field = videobuf_next_field(&fh->cap);
3181                         if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
3182                                 kfree (fh->cap.read_buf);
3183                                 fh->cap.read_buf = NULL;
3184                                 goto err;
3185                         }
3186                         fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
3187                         fh->cap.read_off = 0;
3188                 }
3189                 mutex_unlock(&fh->cap.vb_lock);
3190                 buf = (struct bttv_buffer*)fh->cap.read_buf;
3191         }
3192
3193         poll_wait(file, &buf->vb.done, wait);
3194         if (buf->vb.state == VIDEOBUF_DONE ||
3195             buf->vb.state == VIDEOBUF_ERROR)
3196                 rc =  POLLIN|POLLRDNORM;
3197         else
3198                 rc = 0;
3199 err:
3200         mutex_unlock(&fh->cap.vb_lock);
3201         return rc;
3202 }
3203
3204 static int bttv_open(struct file *file)
3205 {
3206         int minor = video_devdata(file)->minor;
3207         struct bttv *btv = video_drvdata(file);
3208         struct bttv_fh *fh;
3209         enum v4l2_buf_type type = 0;
3210
3211         dprintk(KERN_DEBUG "bttv: open minor=%d\n",minor);
3212
3213         lock_kernel();
3214         if (btv->video_dev->minor == minor) {
3215                 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3216         } else if (btv->vbi_dev->minor == minor) {
3217                 type = V4L2_BUF_TYPE_VBI_CAPTURE;
3218         } else {
3219                 WARN_ON(1);
3220                 unlock_kernel();
3221                 return -ENODEV;
3222         }
3223
3224         dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
3225                 btv->c.nr,v4l2_type_names[type]);
3226
3227         /* allocate per filehandle data */
3228         fh = kmalloc(sizeof(*fh),GFP_KERNEL);
3229         if (NULL == fh) {
3230                 unlock_kernel();
3231                 return -ENOMEM;
3232         }
3233         file->private_data = fh;
3234         *fh = btv->init;
3235         fh->type = type;
3236         fh->ov.setup_ok = 0;
3237         v4l2_prio_open(&btv->prio,&fh->prio);
3238
3239         videobuf_queue_sg_init(&fh->cap, &bttv_video_qops,
3240                             &btv->c.pci->dev, &btv->s_lock,
3241                             V4L2_BUF_TYPE_VIDEO_CAPTURE,
3242                             V4L2_FIELD_INTERLACED,
3243                             sizeof(struct bttv_buffer),
3244                             fh);
3245         videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops,
3246                             &btv->c.pci->dev, &btv->s_lock,
3247                             V4L2_BUF_TYPE_VBI_CAPTURE,
3248                             V4L2_FIELD_SEQ_TB,
3249                             sizeof(struct bttv_buffer),
3250                             fh);
3251         set_tvnorm(btv,btv->tvnorm);
3252         set_input(btv, btv->input, btv->tvnorm);
3253
3254         btv->users++;
3255
3256         /* The V4L2 spec requires one global set of cropping parameters
3257            which only change on request. These are stored in btv->crop[1].
3258            However for compatibility with V4L apps and cropping unaware
3259            V4L2 apps we now reset the cropping parameters as seen through
3260            this fh, which is to say VIDIOC_G_CROP and scaling limit checks
3261            will use btv->crop[0], the default cropping parameters for the
3262            current video standard, and VIDIOC_S_FMT will not implicitely
3263            change the cropping parameters until VIDIOC_S_CROP has been
3264            called. */
3265         fh->do_crop = !reset_crop; /* module parameter */
3266
3267         /* Likewise there should be one global set of VBI capture
3268            parameters, but for compatibility with V4L apps and earlier
3269            driver versions each fh has its own parameters. */
3270         bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3271
3272         bttv_field_count(btv);
3273         unlock_kernel();
3274         return 0;
3275 }
3276
3277 static int bttv_release(struct file *file)
3278 {
3279         struct bttv_fh *fh = file->private_data;
3280         struct bttv *btv = fh->btv;
3281
3282         /* turn off overlay */
3283         if (check_btres(fh, RESOURCE_OVERLAY))
3284                 bttv_switch_overlay(btv,fh,NULL);
3285
3286         /* stop video capture */
3287         if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
3288                 videobuf_streamoff(&fh->cap);
3289                 free_btres(btv,fh,RESOURCE_VIDEO_STREAM);
3290         }
3291         if (fh->cap.read_buf) {
3292                 buffer_release(&fh->cap,fh->cap.read_buf);
3293                 kfree(fh->cap.read_buf);
3294         }
3295         if (check_btres(fh, RESOURCE_VIDEO_READ)) {
3296                 free_btres(btv, fh, RESOURCE_VIDEO_READ);
3297         }
3298
3299         /* stop vbi capture */
3300         if (check_btres(fh, RESOURCE_VBI)) {
3301                 videobuf_stop(&fh->vbi);
3302                 free_btres(btv,fh,RESOURCE_VBI);
3303         }
3304
3305         /* free stuff */
3306         videobuf_mmap_free(&fh->cap);
3307         videobuf_mmap_free(&fh->vbi);
3308         v4l2_prio_close(&btv->prio,&fh->prio);
3309         file->private_data = NULL;
3310         kfree(fh);
3311
3312         btv->users--;
3313         bttv_field_count(btv);
3314
3315         if (!btv->users)
3316                 audio_mute(btv, 1);
3317
3318         return 0;
3319 }
3320
3321 static int
3322 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3323 {
3324         struct bttv_fh *fh = file->private_data;
3325
3326         dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3327                 fh->btv->c.nr, v4l2_type_names[fh->type],
3328                 vma->vm_start, vma->vm_end - vma->vm_start);
3329         return videobuf_mmap_mapper(bttv_queue(fh),vma);
3330 }
3331
3332 static const struct v4l2_file_operations bttv_fops =
3333 {
3334         .owner    = THIS_MODULE,
3335         .open     = bttv_open,
3336         .release  = bttv_release,
3337         .ioctl    = video_ioctl2,
3338         .read     = bttv_read,
3339         .mmap     = bttv_mmap,
3340         .poll     = bttv_poll,
3341 };
3342
3343 static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
3344         .vidioc_querycap                = bttv_querycap,
3345         .vidioc_enum_fmt_vid_cap        = bttv_enum_fmt_vid_cap,
3346         .vidioc_g_fmt_vid_cap           = bttv_g_fmt_vid_cap,
3347         .vidioc_try_fmt_vid_cap         = bttv_try_fmt_vid_cap,
3348         .vidioc_s_fmt_vid_cap           = bttv_s_fmt_vid_cap,
3349         .vidioc_enum_fmt_vid_overlay    = bttv_enum_fmt_vid_overlay,
3350         .vidioc_g_fmt_vid_overlay       = bttv_g_fmt_vid_overlay,
3351         .vidioc_try_fmt_vid_overlay     = bttv_try_fmt_vid_overlay,
3352         .vidioc_s_fmt_vid_overlay       = bttv_s_fmt_vid_overlay,
3353         .vidioc_g_fmt_vbi_cap           = bttv_g_fmt_vbi_cap,
3354         .vidioc_try_fmt_vbi_cap         = bttv_try_fmt_vbi_cap,
3355         .vidioc_s_fmt_vbi_cap           = bttv_s_fmt_vbi_cap,
3356         .vidioc_g_audio                 = bttv_g_audio,
3357         .vidioc_s_audio                 = bttv_s_audio,
3358         .vidioc_cropcap                 = bttv_cropcap,
3359         .vidioc_reqbufs                 = bttv_reqbufs,
3360         .vidioc_querybuf                = bttv_querybuf,
3361         .vidioc_qbuf                    = bttv_qbuf,
3362         .vidioc_dqbuf                   = bttv_dqbuf,
3363         .vidioc_s_std                   = bttv_s_std,
3364         .vidioc_enum_input              = bttv_enum_input,
3365         .vidioc_g_input                 = bttv_g_input,
3366         .vidioc_s_input                 = bttv_s_input,
3367         .vidioc_queryctrl               = bttv_queryctrl,
3368         .vidioc_g_ctrl                  = bttv_g_ctrl,
3369         .vidioc_s_ctrl                  = bttv_s_ctrl,
3370         .vidioc_streamon                = bttv_streamon,
3371         .vidioc_streamoff               = bttv_streamoff,
3372         .vidioc_g_tuner                 = bttv_g_tuner,
3373         .vidioc_s_tuner                 = bttv_s_tuner,
3374 #ifdef CONFIG_VIDEO_V4L1_COMPAT
3375         .vidiocgmbuf                    = vidiocgmbuf,
3376 #endif
3377         .vidioc_g_crop                  = bttv_g_crop,
3378         .vidioc_s_crop                  = bttv_s_crop,
3379         .vidioc_g_fbuf                  = bttv_g_fbuf,
3380         .vidioc_s_fbuf                  = bttv_s_fbuf,
3381         .vidioc_overlay                 = bttv_overlay,
3382         .vidioc_g_priority              = bttv_g_priority,
3383         .vidioc_s_priority              = bttv_s_priority,
3384         .vidioc_g_parm                  = bttv_g_parm,
3385         .vidioc_g_frequency             = bttv_g_frequency,
3386         .vidioc_s_frequency             = bttv_s_frequency,
3387         .vidioc_log_status              = bttv_log_status,
3388         .vidioc_querystd                = bttv_querystd,
3389 #ifdef CONFIG_VIDEO_ADV_DEBUG
3390         .vidioc_g_register              = bttv_g_register,
3391         .vidioc_s_register              = bttv_s_register,
3392 #endif
3393 };
3394
3395 static struct video_device bttv_video_template = {
3396         .fops         = &bttv_fops,
3397         .minor        = -1,
3398         .ioctl_ops    = &bttv_ioctl_ops,
3399         .tvnorms      = BTTV_NORMS,
3400         .current_norm = V4L2_STD_PAL,
3401 };
3402
3403 /* ----------------------------------------------------------------------- */
3404 /* radio interface                                                         */
3405
3406 static int radio_open(struct file *file)
3407 {
3408         int minor = video_devdata(file)->minor;
3409         struct bttv *btv = video_drvdata(file);
3410         struct bttv_fh *fh;
3411
3412         dprintk("bttv: open minor=%d\n",minor);
3413
3414         lock_kernel();
3415         WARN_ON(btv->radio_dev && btv->radio_dev->minor != minor);
3416         if (!btv->radio_dev || btv->radio_dev->minor != minor) {
3417                 unlock_kernel();
3418                 return -ENODEV;
3419         }
3420
3421         dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3422
3423         /* allocate per filehandle data */
3424         fh = kmalloc(sizeof(*fh), GFP_KERNEL);
3425         if (NULL == fh) {
3426                 unlock_kernel();
3427                 return -ENOMEM;
3428         }
3429         file->private_data = fh;
3430         *fh = btv->init;
3431         v4l2_prio_open(&btv->prio, &fh->prio);
3432
3433         mutex_lock(&btv->lock);
3434
3435         btv->radio_user++;
3436
3437         bttv_call_all(btv, tuner, s_radio);
3438         audio_input(btv,TVAUDIO_INPUT_RADIO);
3439
3440         mutex_unlock(&btv->lock);
3441         unlock_kernel();
3442         return 0;
3443 }
3444
3445 static int radio_release(struct file *file)
3446 {
3447         struct bttv_fh *fh = file->private_data;
3448         struct bttv *btv = fh->btv;
3449         struct rds_command cmd;
3450
3451         v4l2_prio_close(&btv->prio,&fh->prio);
3452         file->private_data = NULL;
3453         kfree(fh);
3454
3455         btv->radio_user--;
3456
3457         bttv_call_all(btv, core, ioctl, RDS_CMD_CLOSE, &cmd);
3458
3459         return 0;
3460 }
3461
3462 static int radio_querycap(struct file *file, void *priv,
3463                                         struct v4l2_capability *cap)
3464 {
3465         struct bttv_fh *fh = priv;
3466         struct bttv *btv = fh->btv;
3467
3468         strcpy(cap->driver, "bttv");
3469         strlcpy(cap->card, btv->radio_dev->name, sizeof(cap->card));
3470         sprintf(cap->bus_info, "PCI:%s", pci_name(btv->c.pci));
3471         cap->version = BTTV_VERSION_CODE;
3472         cap->capabilities = V4L2_CAP_TUNER;
3473
3474         return 0;
3475 }
3476
3477 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3478 {
3479         struct bttv_fh *fh = priv;
3480         struct bttv *btv = fh->btv;
3481
3482         if (btv->tuner_type == TUNER_ABSENT)
3483                 return -EINVAL;
3484         if (0 != t->index)
3485                 return -EINVAL;
3486         mutex_lock(&btv->lock);
3487         strcpy(t->name, "Radio");
3488         t->type = V4L2_TUNER_RADIO;
3489
3490         bttv_call_all(btv, tuner, g_tuner, t);
3491
3492         if (btv->audio_mode_gpio)
3493                 btv->audio_mode_gpio(btv, t, 0);
3494
3495         mutex_unlock(&btv->lock);
3496
3497         return 0;
3498 }
3499
3500 static int radio_enum_input(struct file *file, void *priv,
3501                                 struct v4l2_input *i)
3502 {
3503         if (i->index != 0)
3504                 return -EINVAL;
3505
3506         strcpy(i->name, "Radio");
3507         i->type = V4L2_INPUT_TYPE_TUNER;
3508
3509         return 0;
3510 }
3511
3512 static int radio_g_audio(struct file *file, void *priv,
3513                                         struct v4l2_audio *a)
3514 {
3515         if (unlikely(a->index))
3516                 return -EINVAL;
3517
3518         strcpy(a->name, "Radio");
3519
3520         return 0;
3521 }
3522
3523 static int radio_s_tuner(struct file *file, void *priv,
3524                                         struct v4l2_tuner *t)
3525 {
3526         struct bttv_fh *fh = priv;
3527         struct bttv *btv = fh->btv;
3528
3529         if (0 != t->index)
3530                 return -EINVAL;
3531
3532         bttv_call_all(btv, tuner, g_tuner, t);
3533         return 0;
3534 }
3535
3536 static int radio_s_audio(struct file *file, void *priv,
3537                                         struct v4l2_audio *a)
3538 {
3539         if (unlikely(a->index))
3540                 return -EINVAL;
3541
3542         return 0;
3543 }
3544
3545 static int radio_s_input(struct file *filp, void *priv, unsigned int i)
3546 {
3547         if (unlikely(i))
3548                 return -EINVAL;
3549
3550         return 0;
3551 }
3552
3553 static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
3554 {
3555         return 0;
3556 }
3557
3558 static int radio_queryctrl(struct file *file, void *priv,
3559                                         struct v4l2_queryctrl *c)
3560 {
3561         const struct v4l2_queryctrl *ctrl;
3562
3563         if (c->id <  V4L2_CID_BASE ||
3564                         c->id >= V4L2_CID_LASTP1)
3565                 return -EINVAL;
3566
3567         if (c->id == V4L2_CID_AUDIO_MUTE) {
3568                 ctrl = ctrl_by_id(c->id);
3569                 *c = *ctrl;
3570         } else
3571                 *c = no_ctl;
3572
3573         return 0;
3574 }
3575
3576 static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
3577 {
3578         *i = 0;
3579         return 0;
3580 }
3581
3582 static ssize_t radio_read(struct file *file, char __user *data,
3583                          size_t count, loff_t *ppos)
3584 {
3585         struct bttv_fh *fh = file->private_data;
3586         struct bttv *btv = fh->btv;
3587         struct rds_command cmd;
3588         cmd.block_count = count/3;
3589         cmd.buffer = data;
3590         cmd.instance = file;
3591         cmd.result = -ENODEV;
3592
3593         bttv_call_all(btv, core, ioctl, RDS_CMD_READ, &cmd);
3594
3595         return cmd.result;
3596 }
3597
3598 static unsigned int radio_poll(struct file *file, poll_table *wait)
3599 {
3600         struct bttv_fh *fh = file->private_data;
3601         struct bttv *btv = fh->btv;
3602         struct rds_command cmd;
3603         cmd.instance = file;
3604         cmd.event_list = wait;
3605         cmd.result = -ENODEV;
3606         bttv_call_all(btv, core, ioctl, RDS_CMD_POLL, &cmd);
3607
3608         return cmd.result;
3609 }
3610
3611 static const struct v4l2_file_operations radio_fops =
3612 {
3613         .owner    = THIS_MODULE,
3614         .open     = radio_open,
3615         .read     = radio_read,
3616         .release  = radio_release,
3617         .ioctl    = video_ioctl2,
3618         .poll     = radio_poll,
3619 };
3620
3621 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
3622         .vidioc_querycap        = radio_querycap,
3623         .vidioc_g_tuner         = radio_g_tuner,
3624         .vidioc_enum_input      = radio_enum_input,
3625         .vidioc_g_audio         = radio_g_audio,
3626         .vidioc_s_tuner         = radio_s_tuner,
3627         .vidioc_s_audio         = radio_s_audio,
3628         .vidioc_s_input         = radio_s_input,
3629         .vidioc_s_std           = radio_s_std,
3630         .vidioc_queryctrl       = radio_queryctrl,
3631         .vidioc_g_input         = radio_g_input,
3632         .vidioc_g_ctrl          = bttv_g_ctrl,
3633         .vidioc_s_ctrl          = bttv_s_ctrl,
3634         .vidioc_g_frequency     = bttv_g_frequency,
3635         .vidioc_s_frequency     = bttv_s_frequency,
3636 };
3637
3638 static struct video_device radio_template = {
3639         .fops      = &radio_fops,
3640         .minor     = -1,
3641         .ioctl_ops = &radio_ioctl_ops,
3642 };
3643
3644 /* ----------------------------------------------------------------------- */
3645 /* some debug code                                                         */
3646
3647 static int bttv_risc_decode(u32 risc)
3648 {
3649         static char *instr[16] = {
3650                 [ BT848_RISC_WRITE     >> 28 ] = "write",
3651                 [ BT848_RISC_SKIP      >> 28 ] = "skip",
3652                 [ BT848_RISC_WRITEC    >> 28 ] = "writec",
3653                 [ BT848_RISC_JUMP      >> 28 ] = "jump",
3654                 [ BT848_RISC_SYNC      >> 28 ] = "sync",
3655                 [ BT848_RISC_WRITE123  >> 28 ] = "write123",
3656                 [ BT848_RISC_SKIP123   >> 28 ] = "skip123",
3657                 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3658         };
3659         static int incr[16] = {
3660                 [ BT848_RISC_WRITE     >> 28 ] = 2,
3661                 [ BT848_RISC_JUMP      >> 28 ] = 2,
3662                 [ BT848_RISC_SYNC      >> 28 ] = 2,
3663                 [ BT848_RISC_WRITE123  >> 28 ] = 5,
3664                 [ BT848_RISC_SKIP123   >> 28 ] = 2,
3665                 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3666         };
3667         static char *bits[] = {
3668                 "be0",  "be1",  "be2",  "be3/resync",
3669                 "set0", "set1", "set2", "set3",
3670                 "clr0", "clr1", "clr2", "clr3",
3671                 "irq",  "res",  "eol",  "sol",
3672         };
3673         int i;
3674
3675         printk("0x%08x [ %s", risc,
3676                instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3677         for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3678                 if (risc & (1 << (i + 12)))
3679                         printk(" %s",bits[i]);
3680         printk(" count=%d ]\n", risc & 0xfff);
3681         return incr[risc >> 28] ? incr[risc >> 28] : 1;
3682 }
3683
3684 static void bttv_risc_disasm(struct bttv *btv,
3685                              struct btcx_riscmem *risc)
3686 {
3687         unsigned int i,j,n;
3688
3689         printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3690                btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma);
3691         for (i = 0; i < (risc->size >> 2); i += n) {
3692                 printk("%s:   0x%lx: ", btv->c.v4l2_dev.name,
3693                        (unsigned long)(risc->dma + (i<<2)));
3694                 n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
3695                 for (j = 1; j < n; j++)
3696                         printk("%s:   0x%lx: 0x%08x [ arg #%d ]\n",
3697                                btv->c.v4l2_dev.name, (unsigned long)(risc->dma + ((i+j)<<2)),
3698                                risc->cpu[i+j], j);
3699                 if (0 == risc->cpu[i])
3700                         break;
3701         }
3702 }
3703
3704 static void bttv_print_riscaddr(struct bttv *btv)
3705 {
3706         printk("  main: %08Lx\n",
3707                (unsigned long long)btv->main.dma);
3708         printk("  vbi : o=%08Lx e=%08Lx\n",
3709                btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3710                btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3711         printk("  cap : o=%08Lx e=%08Lx\n",
3712                btv->curr.top    ? (unsigned long long)btv->curr.top->top.dma : 0,
3713                btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3714         printk("  scr : o=%08Lx e=%08Lx\n",
3715                btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3716                btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3717         bttv_risc_disasm(btv, &btv->main);
3718 }
3719
3720 /* ----------------------------------------------------------------------- */
3721 /* irq handler                                                             */
3722
3723 static char *irq_name[] = {
3724         "FMTCHG",  // format change detected (525 vs. 625)
3725         "VSYNC",   // vertical sync (new field)
3726         "HSYNC",   // horizontal sync
3727         "OFLOW",   // chroma/luma AGC overflow
3728         "HLOCK",   // horizontal lock changed
3729         "VPRES",   // video presence changed
3730         "6", "7",
3731         "I2CDONE", // hw irc operation finished
3732         "GPINT",   // gpio port triggered irq
3733         "10",
3734         "RISCI",   // risc instruction triggered irq
3735         "FBUS",    // pixel data fifo dropped data (high pci bus latencies)
3736         "FTRGT",   // pixel data fifo overrun
3737         "FDSR",    // fifo data stream resyncronisation
3738         "PPERR",   // parity error (data transfer)
3739         "RIPERR",  // parity error (read risc instructions)
3740         "PABORT",  // pci abort
3741         "OCERR",   // risc instruction error
3742         "SCERR",   // syncronisation error
3743 };
3744
3745 static void bttv_print_irqbits(u32 print, u32 mark)
3746 {
3747         unsigned int i;
3748
3749         printk("bits:");
3750         for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3751                 if (print & (1 << i))
3752                         printk(" %s",irq_name[i]);
3753                 if (mark & (1 << i))
3754                         printk("*");
3755         }
3756 }
3757
3758 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3759 {
3760         printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3761                btv->c.nr,
3762                (unsigned long)btv->main.dma,
3763                (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
3764                (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
3765                (unsigned long)rc);
3766
3767         if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3768                 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3769                        "Ok, then this is harmless, don't worry ;)\n",
3770                        btv->c.nr);
3771                 return;
3772         }
3773         printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3774                btv->c.nr);
3775         printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3776                btv->c.nr);
3777         dump_stack();
3778 }
3779
3780 static int
3781 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3782 {
3783         struct bttv_buffer *item;
3784
3785         memset(set,0,sizeof(*set));
3786
3787         /* capture request ? */
3788         if (!list_empty(&btv->capture)) {
3789                 set->frame_irq = 1;
3790                 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3791                 if (V4L2_FIELD_HAS_TOP(item->vb.field))
3792                         set->top    = item;
3793                 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3794                         set->bottom = item;
3795
3796                 /* capture request for other field ? */
3797                 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3798                     (item->vb.queue.next != &btv->capture)) {
3799                         item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3800                         if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3801                                 if (NULL == set->top &&
3802                                     V4L2_FIELD_TOP == item->vb.field) {
3803                                         set->top = item;
3804                                 }
3805                                 if (NULL == set->bottom &&
3806                                     V4L2_FIELD_BOTTOM == item->vb.field) {
3807                                         set->bottom = item;
3808                                 }
3809                                 if (NULL != set->top  &&  NULL != set->bottom)
3810                                         set->top_irq = 2;
3811                         }
3812                 }
3813         }
3814
3815         /* screen overlay ? */
3816         if (NULL != btv->screen) {
3817                 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3818                         if (NULL == set->top && NULL == set->bottom) {
3819                                 set->top    = btv->screen;
3820                                 set->bottom = btv->screen;
3821                         }
3822                 } else {
3823                         if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3824                             NULL == set->top) {
3825                                 set->top = btv->screen;
3826                         }
3827                         if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3828                             NULL == set->bottom) {
3829                                 set->bottom = btv->screen;
3830                         }
3831                 }
3832         }
3833
3834         dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3835                 btv->c.nr,set->top, set->bottom,
3836                 btv->screen,set->frame_irq,set->top_irq);
3837         return 0;
3838 }
3839
3840 static void
3841 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3842                       struct bttv_buffer_set *curr, unsigned int state)
3843 {
3844         struct timeval ts;
3845
3846         do_gettimeofday(&ts);
3847
3848         if (wakeup->top == wakeup->bottom) {
3849                 if (NULL != wakeup->top && curr->top != wakeup->top) {
3850                         if (irq_debug > 1)
3851                                 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
3852                         wakeup->top->vb.ts = ts;
3853                         wakeup->top->vb.field_count = btv->field_count;
3854                         wakeup->top->vb.state = state;
3855                         wake_up(&wakeup->top->vb.done);
3856                 }
3857         } else {
3858                 if (NULL != wakeup->top && curr->top != wakeup->top) {
3859                         if (irq_debug > 1)
3860                                 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
3861                         wakeup->top->vb.ts = ts;
3862                         wakeup->top->vb.field_count = btv->field_count;
3863                         wakeup->top->vb.state = state;
3864                         wake_up(&wakeup->top->vb.done);
3865                 }
3866                 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3867                         if (irq_debug > 1)
3868                                 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
3869                         wakeup->bottom->vb.ts = ts;
3870                         wakeup->bottom->vb.field_count = btv->field_count;
3871                         wakeup->bottom->vb.state = state;
3872                         wake_up(&wakeup->bottom->vb.done);
3873                 }
3874         }
3875 }
3876
3877 static void
3878 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3879                     unsigned int state)
3880 {
3881         struct timeval ts;
3882
3883         if (NULL == wakeup)
3884                 return;
3885
3886         do_gettimeofday(&ts);
3887         wakeup->vb.ts = ts;
3888         wakeup->vb.field_count = btv->field_count;
3889         wakeup->vb.state = state;
3890         wake_up(&wakeup->vb.done);
3891 }
3892
3893 static void bttv_irq_timeout(unsigned long data)
3894 {
3895         struct bttv *btv = (struct bttv *)data;
3896         struct bttv_buffer_set old,new;
3897         struct bttv_buffer *ovbi;
3898         struct bttv_buffer *item;
3899         unsigned long flags;
3900
3901         if (bttv_verbose) {
3902                 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3903                        btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3904                        btread(BT848_RISC_COUNT));
3905                 bttv_print_irqbits(btread(BT848_INT_STAT),0);
3906                 printk("\n");
3907         }
3908
3909         spin_lock_irqsave(&btv->s_lock,flags);
3910
3911         /* deactivate stuff */
3912         memset(&new,0,sizeof(new));
3913         old  = btv->curr;
3914         ovbi = btv->cvbi;
3915         btv->curr = new;
3916         btv->cvbi = NULL;
3917         btv->loop_irq = 0;
3918         bttv_buffer_activate_video(btv, &new);
3919         bttv_buffer_activate_vbi(btv,   NULL);
3920         bttv_set_dma(btv, 0);
3921
3922         /* wake up */
3923         bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
3924         bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
3925
3926         /* cancel all outstanding capture / vbi requests */
3927         while (!list_empty(&btv->capture)) {
3928                 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3929                 list_del(&item->vb.queue);
3930                 item->vb.state = VIDEOBUF_ERROR;
3931                 wake_up(&item->vb.done);
3932         }
3933         while (!list_empty(&btv->vcapture)) {
3934                 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3935                 list_del(&item->vb.queue);
3936                 item->vb.state = VIDEOBUF_ERROR;
3937                 wake_up(&item->vb.done);
3938         }
3939
3940         btv->errors++;
3941         spin_unlock_irqrestore(&btv->s_lock,flags);
3942 }
3943
3944 static void
3945 bttv_irq_wakeup_top(struct bttv *btv)
3946 {
3947         struct bttv_buffer *wakeup = btv->curr.top;
3948
3949         if (NULL == wakeup)
3950                 return;
3951
3952         spin_lock(&btv->s_lock);
3953         btv->curr.top_irq = 0;
3954         btv->curr.top = NULL;
3955         bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3956
3957         do_gettimeofday(&wakeup->vb.ts);
3958         wakeup->vb.field_count = btv->field_count;
3959         wakeup->vb.state = VIDEOBUF_DONE;
3960         wake_up(&wakeup->vb.done);
3961         spin_unlock(&btv->s_lock);
3962 }
3963
3964 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
3965 {
3966         if (rc < risc->dma)
3967                 return 0;
3968         if (rc > risc->dma + risc->size)
3969                 return 0;
3970         return 1;
3971 }
3972
3973 static void
3974 bttv_irq_switch_video(struct bttv *btv)
3975 {
3976         struct bttv_buffer_set new;
3977         struct bttv_buffer_set old;
3978         dma_addr_t rc;
3979
3980         spin_lock(&btv->s_lock);
3981
3982         /* new buffer set */
3983         bttv_irq_next_video(btv, &new);
3984         rc = btread(BT848_RISC_COUNT);
3985         if ((btv->curr.top    && is_active(&btv->curr.top->top,       rc)) ||
3986             (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
3987                 btv->framedrop++;
3988                 if (debug_latency)
3989                         bttv_irq_debug_low_latency(btv, rc);
3990                 spin_unlock(&btv->s_lock);
3991                 return;
3992         }
3993
3994         /* switch over */
3995         old = btv->curr;
3996         btv->curr = new;
3997         btv->loop_irq &= ~1;
3998         bttv_buffer_activate_video(btv, &new);
3999         bttv_set_dma(btv, 0);
4000
4001         /* switch input */
4002         if (UNSET != btv->new_input) {
4003                 video_mux(btv,btv->new_input);
4004                 btv->new_input = UNSET;
4005         }
4006
4007         /* wake up finished buffers */
4008         bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
4009         spin_unlock(&btv->s_lock);
4010 }
4011
4012 static void
4013 bttv_irq_switch_vbi(struct bttv *btv)
4014 {
4015         struct bttv_buffer *new = NULL;
4016         struct bttv_buffer *old;
4017         u32 rc;
4018
4019         spin_lock(&btv->s_lock);
4020
4021         if (!list_empty(&btv->vcapture))
4022                 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4023         old = btv->cvbi;
4024
4025         rc = btread(BT848_RISC_COUNT);
4026         if (NULL != old && (is_active(&old->top,    rc) ||
4027                             is_active(&old->bottom, rc))) {
4028                 btv->framedrop++;
4029                 if (debug_latency)
4030                         bttv_irq_debug_low_latency(btv, rc);
4031                 spin_unlock(&btv->s_lock);
4032                 return;
4033         }
4034
4035         /* switch */
4036         btv->cvbi = new;
4037         btv->loop_irq &= ~4;
4038         bttv_buffer_activate_vbi(btv, new);
4039         bttv_set_dma(btv, 0);
4040
4041         bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
4042         spin_unlock(&btv->s_lock);
4043 }
4044
4045 static irqreturn_t bttv_irq(int irq, void *dev_id)
4046 {
4047         u32 stat,astat;
4048         u32 dstat;
4049         int count;
4050         struct bttv *btv;
4051         int handled = 0;
4052
4053         btv=(struct bttv *)dev_id;
4054
4055         if (btv->custom_irq)
4056                 handled = btv->custom_irq(btv);
4057
4058         count=0;
4059         while (1) {
4060                 /* get/clear interrupt status bits */
4061                 stat=btread(BT848_INT_STAT);
4062                 astat=stat&btread(BT848_INT_MASK);
4063                 if (!astat)
4064                         break;
4065                 handled = 1;
4066                 btwrite(stat,BT848_INT_STAT);
4067
4068                 /* get device status bits */
4069                 dstat=btread(BT848_DSTATUS);
4070
4071                 if (irq_debug) {
4072                         printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
4073                                "riscs=%x, riscc=%08x, ",
4074                                btv->c.nr, count, btv->field_count,
4075                                stat>>28, btread(BT848_RISC_COUNT));
4076                         bttv_print_irqbits(stat,astat);
4077                         if (stat & BT848_INT_HLOCK)
4078                                 printk("   HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
4079                                        ? "yes" : "no");
4080                         if (stat & BT848_INT_VPRES)
4081                                 printk("   PRES => %s", (dstat & BT848_DSTATUS_PRES)
4082                                        ? "yes" : "no");
4083                         if (stat & BT848_INT_FMTCHG)
4084                                 printk("   NUML => %s", (dstat & BT848_DSTATUS_NUML)
4085                                        ? "625" : "525");
4086                         printk("\n");
4087                 }
4088
4089                 if (astat&BT848_INT_VSYNC)
4090                         btv->field_count++;
4091
4092                 if ((astat & BT848_INT_GPINT) && btv->remote) {
4093                         wake_up(&btv->gpioq);
4094                         bttv_input_irq(btv);
4095                 }
4096
4097                 if (astat & BT848_INT_I2CDONE) {
4098                         btv->i2c_done = stat;
4099                         wake_up(&btv->i2c_queue);
4100                 }
4101
4102                 if ((astat & BT848_INT_RISCI)  &&  (stat & (4<<28)))
4103                         bttv_irq_switch_vbi(btv);
4104
4105                 if ((astat & BT848_INT_RISCI)  &&  (stat & (2<<28)))
4106                         bttv_irq_wakeup_top(btv);
4107
4108                 if ((astat & BT848_INT_RISCI)  &&  (stat & (1<<28)))
4109                         bttv_irq_switch_video(btv);
4110
4111                 if ((astat & BT848_INT_HLOCK)  &&  btv->opt_automute)
4112                         audio_mute(btv, btv->mute);  /* trigger automute */
4113
4114                 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
4115                         printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
4116                                (astat & BT848_INT_SCERR) ? "SCERR" : "",
4117                                (astat & BT848_INT_OCERR) ? "OCERR" : "",
4118                                btread(BT848_RISC_COUNT));
4119                         bttv_print_irqbits(stat,astat);
4120                         printk("\n");
4121                         if (bttv_debug)
4122                                 bttv_print_riscaddr(btv);
4123                 }
4124                 if (fdsr && astat & BT848_INT_FDSR) {
4125                         printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
4126                                btv->c.nr,btread(BT848_RISC_COUNT));
4127                         if (bttv_debug)
4128                                 bttv_print_riscaddr(btv);
4129                 }
4130
4131                 count++;
4132                 if (count > 4) {
4133
4134                         if (count > 8 || !(astat & BT848_INT_GPINT)) {
4135                                 btwrite(0, BT848_INT_MASK);
4136
4137                                 printk(KERN_ERR
4138                                            "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
4139                         } else {
4140                                 printk(KERN_ERR
4141                                            "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
4142
4143                                 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
4144                                                 BT848_INT_MASK);
4145                         };
4146
4147                         bttv_print_irqbits(stat,astat);
4148
4149                         printk("]\n");
4150                 }
4151         }
4152         btv->irq_total++;
4153         if (handled)
4154                 btv->irq_me++;
4155         return IRQ_RETVAL(handled);
4156 }
4157
4158
4159 /* ----------------------------------------------------------------------- */
4160 /* initialitation                                                          */
4161
4162 static struct video_device *vdev_init(struct bttv *btv,
4163                                       const struct video_device *template,
4164                                       const char *type_name)
4165 {
4166         struct video_device *vfd;
4167
4168         vfd = video_device_alloc();
4169         if (NULL == vfd)
4170                 return NULL;
4171         *vfd = *template;
4172         vfd->v4l2_dev = &btv->c.v4l2_dev;
4173         vfd->release = video_device_release;
4174         vfd->debug   = bttv_debug;
4175         video_set_drvdata(vfd, btv);
4176         snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
4177                  btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
4178                  type_name, bttv_tvcards[btv->c.type].name);
4179         return vfd;
4180 }
4181
4182 static void bttv_unregister_video(struct bttv *btv)
4183 {
4184         if (btv->video_dev) {
4185                 if (-1 != btv->video_dev->minor)
4186                         video_unregister_device(btv->video_dev);
4187                 else
4188                         video_device_release(btv->video_dev);
4189                 btv->video_dev = NULL;
4190         }
4191         if (btv->vbi_dev) {
4192                 if (-1 != btv->vbi_dev->minor)
4193                         video_unregister_device(btv->vbi_dev);
4194                 else
4195                         video_device_release(btv->vbi_dev);
4196                 btv->vbi_dev = NULL;
4197         }
4198         if (btv->radio_dev) {
4199                 if (-1 != btv->radio_dev->minor)
4200                         video_unregister_device(btv->radio_dev);
4201                 else
4202                         video_device_release(btv->radio_dev);
4203                 btv->radio_dev = NULL;
4204         }
4205 }
4206
4207 /* register video4linux devices */
4208 static int __devinit bttv_register_video(struct bttv *btv)
4209 {
4210         if (no_overlay > 0)
4211                 printk("bttv: Overlay support disabled.\n");
4212
4213         /* video */
4214         btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
4215
4216         if (NULL == btv->video_dev)
4217                 goto err;
4218         if (video_register_device(btv->video_dev, VFL_TYPE_GRABBER,
4219                                   video_nr[btv->c.nr]) < 0)
4220                 goto err;
4221         printk(KERN_INFO "bttv%d: registered device video%d\n",
4222                btv->c.nr, btv->video_dev->num);
4223         if (device_create_file(&btv->video_dev->dev,
4224                                      &dev_attr_card)<0) {
4225                 printk(KERN_ERR "bttv%d: device_create_file 'card' "
4226                        "failed\n", btv->c.nr);
4227                 goto err;
4228         }
4229
4230         /* vbi */
4231         btv->vbi_dev = vdev_init(btv, &bttv_video_template, "vbi");
4232
4233         if (NULL == btv->vbi_dev)
4234                 goto err;
4235         if (video_register_device(btv->vbi_dev, VFL_TYPE_VBI,
4236                                   vbi_nr[btv->c.nr]) < 0)
4237                 goto err;
4238         printk(KERN_INFO "bttv%d: registered device vbi%d\n",
4239                btv->c.nr, btv->vbi_dev->num);
4240
4241         if (!btv->has_radio)
4242                 return 0;
4243         /* radio */
4244         btv->radio_dev = vdev_init(btv, &radio_template, "radio");
4245         if (NULL == btv->radio_dev)
4246                 goto err;
4247         if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,
4248                                   radio_nr[btv->c.nr]) < 0)
4249                 goto err;
4250         printk(KERN_INFO "bttv%d: registered device radio%d\n",
4251                btv->c.nr, btv->radio_dev->num);
4252
4253         /* all done */
4254         return 0;
4255
4256  err:
4257         bttv_unregister_video(btv);
4258         return -1;
4259 }
4260
4261
4262 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
4263 /* response on cards with no firmware is not enabled by OF */
4264 static void pci_set_command(struct pci_dev *dev)
4265 {
4266 #if defined(__powerpc__)
4267         unsigned int cmd;
4268
4269         pci_read_config_dword(dev, PCI_COMMAND, &cmd);
4270         cmd = (cmd | PCI_COMMAND_MEMORY );
4271         pci_write_config_dword(dev, PCI_COMMAND, cmd);
4272 #endif
4273 }
4274
4275 static int __devinit bttv_probe(struct pci_dev *dev,
4276                                 const struct pci_device_id *pci_id)
4277 {
4278         int result;
4279         unsigned char lat;
4280         struct bttv *btv;
4281
4282         if (bttv_num == BTTV_MAX)
4283                 return -ENOMEM;
4284         printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
4285         bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL);
4286         if (btv == NULL) {
4287                 printk(KERN_ERR "bttv: out of memory.\n");
4288                 return -ENOMEM;
4289         }
4290         btv->c.nr  = bttv_num;
4291         snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name),
4292                         "bttv%d", btv->c.nr);
4293
4294         /* initialize structs / fill in defaults */
4295         mutex_init(&btv->lock);
4296         spin_lock_init(&btv->s_lock);
4297         spin_lock_init(&btv->gpio_lock);
4298         init_waitqueue_head(&btv->gpioq);
4299         init_waitqueue_head(&btv->i2c_queue);
4300         INIT_LIST_HEAD(&btv->c.subs);
4301         INIT_LIST_HEAD(&btv->capture);
4302         INIT_LIST_HEAD(&btv->vcapture);
4303         v4l2_prio_init(&btv->prio);
4304
4305         init_timer(&btv->timeout);
4306         btv->timeout.function = bttv_irq_timeout;
4307         btv->timeout.data     = (unsigned long)btv;
4308
4309         btv->i2c_rc = -1;
4310         btv->tuner_type  = UNSET;
4311         btv->new_input   = UNSET;
4312         btv->has_radio=radio[btv->c.nr];
4313
4314         /* pci stuff (init, get irq/mmio, ... */
4315         btv->c.pci = dev;
4316         btv->id  = dev->device;
4317         if (pci_enable_device(dev)) {
4318                 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4319                        btv->c.nr);
4320                 return -EIO;
4321         }
4322         if (pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
4323                 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
4324                        btv->c.nr);
4325                 return -EIO;
4326         }
4327         if (!request_mem_region(pci_resource_start(dev,0),
4328                                 pci_resource_len(dev,0),
4329                                 btv->c.v4l2_dev.name)) {
4330                 printk(KERN_WARNING "bttv%d: can't request iomem (0x%llx).\n",
4331                        btv->c.nr,
4332                        (unsigned long long)pci_resource_start(dev,0));
4333                 return -EBUSY;
4334         }
4335         pci_set_master(dev);
4336         pci_set_command(dev);
4337
4338         result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev);
4339         if (result < 0) {
4340                 printk(KERN_WARNING "bttv%d: v4l2_device_register() failed\n", btv->c.nr);
4341                 goto fail0;
4342         }
4343
4344         pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
4345         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4346         printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
4347                bttv_num,btv->id, btv->revision, pci_name(dev));
4348         printk("irq: %d, latency: %d, mmio: 0x%llx\n",
4349                btv->c.pci->irq, lat,
4350                (unsigned long long)pci_resource_start(dev,0));
4351         schedule();
4352
4353         btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4354         if (NULL == btv->bt848_mmio) {
4355                 printk("bttv%d: ioremap() failed\n", btv->c.nr);
4356                 result = -EIO;
4357                 goto fail1;
4358         }
4359
4360         /* identify card */
4361         bttv_idcard(btv);
4362
4363         /* disable irqs, register irq handler */
4364         btwrite(0, BT848_INT_MASK);
4365         result = request_irq(btv->c.pci->irq, bttv_irq,
4366             IRQF_SHARED | IRQF_DISABLED, btv->c.v4l2_dev.name, (void *)btv);
4367         if (result < 0) {
4368                 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
4369                        bttv_num,btv->c.pci->irq);
4370                 goto fail1;
4371         }
4372
4373         if (0 != bttv_handle_chipset(btv)) {
4374                 result = -EIO;
4375                 goto fail2;
4376         }
4377
4378         /* init options from insmod args */
4379         btv->opt_combfilter = combfilter;
4380         btv->opt_lumafilter = lumafilter;
4381         btv->opt_automute   = automute;
4382         btv->opt_chroma_agc = chroma_agc;
4383         btv->opt_adc_crush  = adc_crush;
4384         btv->opt_vcr_hack   = vcr_hack;
4385         btv->opt_whitecrush_upper  = whitecrush_upper;
4386         btv->opt_whitecrush_lower  = whitecrush_lower;
4387         btv->opt_uv_ratio   = uv_ratio;
4388         btv->opt_full_luma_range   = full_luma_range;
4389         btv->opt_coring     = coring;
4390
4391         /* fill struct bttv with some useful defaults */
4392         btv->init.btv         = btv;
4393         btv->init.ov.w.width  = 320;
4394         btv->init.ov.w.height = 240;
4395         btv->init.fmt         = format_by_fourcc(V4L2_PIX_FMT_BGR24);
4396         btv->init.width       = 320;
4397         btv->init.height      = 240;
4398         btv->input = 0;
4399
4400         /* initialize hardware */
4401         if (bttv_gpio)
4402                 bttv_gpio_tracking(btv,"pre-init");
4403
4404         bttv_risc_init_main(btv);
4405         init_bt848(btv);
4406
4407         /* gpio */
4408         btwrite(0x00, BT848_GPIO_REG_INP);
4409         btwrite(0x00, BT848_GPIO_OUT_EN);
4410         if (bttv_verbose)
4411                 bttv_gpio_tracking(btv,"init");
4412
4413         /* needs to be done before i2c is registered */
4414         bttv_init_card1(btv);
4415
4416         /* register i2c + gpio */
4417         init_bttv_i2c(btv);
4418
4419         /* some card-specific stuff (needs working i2c) */
4420         bttv_init_card2(btv);
4421         init_irqreg(btv);
4422
4423         /* register video4linux + input */
4424         if (!bttv_tvcards[btv->c.type].no_video) {
4425                 bttv_register_video(btv);
4426                 bt848_bright(btv,32768);
4427                 bt848_contrast(btv,32768);
4428                 bt848_hue(btv,32768);
4429                 bt848_sat(btv,32768);
4430                 audio_mute(btv, 1);
4431                 set_input(btv, 0, btv->tvnorm);
4432                 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4433                 btv->crop[1] = btv->crop[0]; /* current = default */
4434                 disclaim_vbi_lines(btv);
4435                 disclaim_video_lines(btv);
4436         }
4437
4438         /* add subdevices and autoload dvb-bt8xx if needed */
4439         if (bttv_tvcards[btv->c.type].has_dvb) {
4440                 bttv_sub_add_device(&btv->c, "dvb");
4441                 request_modules(btv);
4442         }
4443
4444         bttv_input_init(btv);
4445
4446         /* everything is fine */
4447         bttv_num++;
4448         return 0;
4449
4450 fail2:
4451         free_irq(btv->c.pci->irq,btv);
4452
4453 fail1:
4454         v4l2_device_unregister(&btv->c.v4l2_dev);
4455
4456 fail0:
4457         if (btv->bt848_mmio)
4458                 iounmap(btv->bt848_mmio);
4459         release_mem_region(pci_resource_start(btv->c.pci,0),
4460                            pci_resource_len(btv->c.pci,0));
4461         return result;
4462 }
4463
4464 static void __devexit bttv_remove(struct pci_dev *pci_dev)
4465 {
4466         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4467         struct bttv *btv = to_bttv(v4l2_dev);
4468
4469         if (bttv_verbose)
4470                 printk("bttv%d: unloading\n",btv->c.nr);
4471
4472         /* shutdown everything (DMA+IRQs) */
4473         btand(~15, BT848_GPIO_DMA_CTL);
4474         btwrite(0, BT848_INT_MASK);
4475         btwrite(~0x0, BT848_INT_STAT);
4476         btwrite(0x0, BT848_GPIO_OUT_EN);
4477         if (bttv_gpio)
4478                 bttv_gpio_tracking(btv,"cleanup");
4479
4480         /* tell gpio modules we are leaving ... */
4481         btv->shutdown=1;
4482         wake_up(&btv->gpioq);
4483         bttv_input_fini(btv);
4484         bttv_sub_del_devices(&btv->c);
4485
4486         /* unregister i2c_bus + input */
4487         fini_bttv_i2c(btv);
4488
4489         /* unregister video4linux */
4490         bttv_unregister_video(btv);
4491
4492         /* free allocated memory */
4493         btcx_riscmem_free(btv->c.pci,&btv->main);
4494
4495         /* free ressources */
4496         free_irq(btv->c.pci->irq,btv);
4497         iounmap(btv->bt848_mmio);
4498         release_mem_region(pci_resource_start(btv->c.pci,0),
4499                            pci_resource_len(btv->c.pci,0));
4500
4501         v4l2_device_unregister(&btv->c.v4l2_dev);
4502         bttvs[btv->c.nr] = NULL;
4503         kfree(btv);
4504
4505         return;
4506 }
4507
4508 #ifdef CONFIG_PM
4509 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4510 {
4511         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4512         struct bttv *btv = to_bttv(v4l2_dev);
4513         struct bttv_buffer_set idle;
4514         unsigned long flags;
4515
4516         dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
4517
4518         /* stop dma + irqs */
4519         spin_lock_irqsave(&btv->s_lock,flags);
4520         memset(&idle, 0, sizeof(idle));
4521         btv->state.video = btv->curr;
4522         btv->state.vbi   = btv->cvbi;
4523         btv->state.loop_irq = btv->loop_irq;
4524         btv->curr = idle;
4525         btv->loop_irq = 0;
4526         bttv_buffer_activate_video(btv, &idle);
4527         bttv_buffer_activate_vbi(btv, NULL);
4528         bttv_set_dma(btv, 0);
4529         btwrite(0, BT848_INT_MASK);
4530         spin_unlock_irqrestore(&btv->s_lock,flags);
4531
4532         /* save bt878 state */
4533         btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4534         btv->state.gpio_data   = gpio_read();
4535
4536         /* save pci state */
4537         pci_save_state(pci_dev);
4538         if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4539                 pci_disable_device(pci_dev);
4540                 btv->state.disabled = 1;
4541         }
4542         return 0;
4543 }
4544
4545 static int bttv_resume(struct pci_dev *pci_dev)
4546 {
4547         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4548         struct bttv *btv = to_bttv(v4l2_dev);
4549         unsigned long flags;
4550         int err;
4551
4552         dprintk("bttv%d: resume\n", btv->c.nr);
4553
4554         /* restore pci state */
4555         if (btv->state.disabled) {
4556                 err=pci_enable_device(pci_dev);
4557                 if (err) {
4558                         printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4559                                                                 btv->c.nr);
4560                         return err;
4561                 }
4562                 btv->state.disabled = 0;
4563         }
4564         err=pci_set_power_state(pci_dev, PCI_D0);
4565         if (err) {
4566                 pci_disable_device(pci_dev);
4567                 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4568                                                         btv->c.nr);
4569                 btv->state.disabled = 1;
4570                 return err;
4571         }
4572
4573         pci_restore_state(pci_dev);
4574
4575         /* restore bt878 state */
4576         bttv_reinit_bt848(btv);
4577         gpio_inout(0xffffff, btv->state.gpio_enable);
4578         gpio_write(btv->state.gpio_data);
4579
4580         /* restart dma */
4581         spin_lock_irqsave(&btv->s_lock,flags);
4582         btv->curr = btv->state.video;
4583         btv->cvbi = btv->state.vbi;
4584         btv->loop_irq = btv->state.loop_irq;
4585         bttv_buffer_activate_video(btv, &btv->curr);
4586         bttv_buffer_activate_vbi(btv, btv->cvbi);
4587         bttv_set_dma(btv, 0);
4588         spin_unlock_irqrestore(&btv->s_lock,flags);
4589         return 0;
4590 }
4591 #endif
4592
4593 static struct pci_device_id bttv_pci_tbl[] = {
4594         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
4595          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4596         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
4597          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4598         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
4599          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4600         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
4601          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4602         {0,}
4603 };
4604
4605 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4606
4607 static struct pci_driver bttv_pci_driver = {
4608         .name     = "bttv",
4609         .id_table = bttv_pci_tbl,
4610         .probe    = bttv_probe,
4611         .remove   = __devexit_p(bttv_remove),
4612 #ifdef CONFIG_PM
4613         .suspend  = bttv_suspend,
4614         .resume   = bttv_resume,
4615 #endif
4616 };
4617
4618 static int __init bttv_init_module(void)
4619 {
4620         int ret;
4621
4622         bttv_num = 0;
4623
4624         printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4625                (BTTV_VERSION_CODE >> 16) & 0xff,
4626                (BTTV_VERSION_CODE >> 8) & 0xff,
4627                BTTV_VERSION_CODE & 0xff);
4628 #ifdef SNAPSHOT
4629         printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4630                SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4631 #endif
4632         if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4633                 gbuffers = 2;
4634         if (gbufsize > BTTV_MAX_FBUF)
4635                 gbufsize = BTTV_MAX_FBUF;
4636         gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4637         if (bttv_verbose)
4638                 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4639                        gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4640
4641         bttv_check_chipset();
4642
4643         ret = bus_register(&bttv_sub_bus_type);
4644         if (ret < 0) {
4645                 printk(KERN_WARNING "bttv: bus_register error: %d\n", ret);
4646                 return ret;
4647         }
4648         ret = pci_register_driver(&bttv_pci_driver);
4649         if (ret < 0)
4650                 bus_unregister(&bttv_sub_bus_type);
4651
4652         return ret;
4653 }
4654
4655 static void __exit bttv_cleanup_module(void)
4656 {
4657         pci_unregister_driver(&bttv_pci_driver);
4658         bus_unregister(&bttv_sub_bus_type);
4659 }
4660
4661 module_init(bttv_init_module);
4662 module_exit(bttv_cleanup_module);
4663
4664 /*
4665  * Local variables:
4666  * c-basic-offset: 8
4667  * End:
4668  */