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
3156         if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
3157                 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3158                         return POLLERR;
3159                 return videobuf_poll_stream(file, &fh->vbi, wait);
3160         }
3161
3162         if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
3163                 /* streaming capture */
3164                 if (list_empty(&fh->cap.stream))
3165                         return POLLERR;
3166                 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
3167         } else {
3168                 /* read() capture */
3169                 mutex_lock(&fh->cap.vb_lock);
3170                 if (NULL == fh->cap.read_buf) {
3171                         /* need to capture a new frame */
3172                         if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
3173                                 goto err;
3174                         fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize);
3175                         if (NULL == fh->cap.read_buf)
3176                                 goto err;
3177                         fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
3178                         field = videobuf_next_field(&fh->cap);
3179                         if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
3180                                 kfree (fh->cap.read_buf);
3181                                 fh->cap.read_buf = NULL;
3182                                 goto err;
3183                         }
3184                         fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
3185                         fh->cap.read_off = 0;
3186                 }
3187                 mutex_unlock(&fh->cap.vb_lock);
3188                 buf = (struct bttv_buffer*)fh->cap.read_buf;
3189         }
3190
3191         poll_wait(file, &buf->vb.done, wait);
3192         if (buf->vb.state == VIDEOBUF_DONE ||
3193             buf->vb.state == VIDEOBUF_ERROR)
3194                 return POLLIN|POLLRDNORM;
3195         return 0;
3196 err:
3197         mutex_unlock(&fh->cap.vb_lock);
3198         return POLLERR;
3199 }
3200
3201 static int bttv_open(struct file *file)
3202 {
3203         int minor = video_devdata(file)->minor;
3204         struct bttv *btv = video_drvdata(file);
3205         struct bttv_fh *fh;
3206         enum v4l2_buf_type type = 0;
3207
3208         dprintk(KERN_DEBUG "bttv: open minor=%d\n",minor);
3209
3210         lock_kernel();
3211         if (btv->video_dev->minor == minor) {
3212                 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3213         } else if (btv->vbi_dev->minor == minor) {
3214                 type = V4L2_BUF_TYPE_VBI_CAPTURE;
3215         } else {
3216                 WARN_ON(1);
3217                 unlock_kernel();
3218                 return -ENODEV;
3219         }
3220
3221         dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
3222                 btv->c.nr,v4l2_type_names[type]);
3223
3224         /* allocate per filehandle data */
3225         fh = kmalloc(sizeof(*fh),GFP_KERNEL);
3226         if (NULL == fh) {
3227                 unlock_kernel();
3228                 return -ENOMEM;
3229         }
3230         file->private_data = fh;
3231         *fh = btv->init;
3232         fh->type = type;
3233         fh->ov.setup_ok = 0;
3234         v4l2_prio_open(&btv->prio,&fh->prio);
3235
3236         videobuf_queue_sg_init(&fh->cap, &bttv_video_qops,
3237                             &btv->c.pci->dev, &btv->s_lock,
3238                             V4L2_BUF_TYPE_VIDEO_CAPTURE,
3239                             V4L2_FIELD_INTERLACED,
3240                             sizeof(struct bttv_buffer),
3241                             fh);
3242         videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops,
3243                             &btv->c.pci->dev, &btv->s_lock,
3244                             V4L2_BUF_TYPE_VBI_CAPTURE,
3245                             V4L2_FIELD_SEQ_TB,
3246                             sizeof(struct bttv_buffer),
3247                             fh);
3248         set_tvnorm(btv,btv->tvnorm);
3249         set_input(btv, btv->input, btv->tvnorm);
3250
3251         btv->users++;
3252
3253         /* The V4L2 spec requires one global set of cropping parameters
3254            which only change on request. These are stored in btv->crop[1].
3255            However for compatibility with V4L apps and cropping unaware
3256            V4L2 apps we now reset the cropping parameters as seen through
3257            this fh, which is to say VIDIOC_G_CROP and scaling limit checks
3258            will use btv->crop[0], the default cropping parameters for the
3259            current video standard, and VIDIOC_S_FMT will not implicitely
3260            change the cropping parameters until VIDIOC_S_CROP has been
3261            called. */
3262         fh->do_crop = !reset_crop; /* module parameter */
3263
3264         /* Likewise there should be one global set of VBI capture
3265            parameters, but for compatibility with V4L apps and earlier
3266            driver versions each fh has its own parameters. */
3267         bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3268
3269         bttv_field_count(btv);
3270         unlock_kernel();
3271         return 0;
3272 }
3273
3274 static int bttv_release(struct file *file)
3275 {
3276         struct bttv_fh *fh = file->private_data;
3277         struct bttv *btv = fh->btv;
3278
3279         /* turn off overlay */
3280         if (check_btres(fh, RESOURCE_OVERLAY))
3281                 bttv_switch_overlay(btv,fh,NULL);
3282
3283         /* stop video capture */
3284         if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
3285                 videobuf_streamoff(&fh->cap);
3286                 free_btres(btv,fh,RESOURCE_VIDEO_STREAM);
3287         }
3288         if (fh->cap.read_buf) {
3289                 buffer_release(&fh->cap,fh->cap.read_buf);
3290                 kfree(fh->cap.read_buf);
3291         }
3292         if (check_btres(fh, RESOURCE_VIDEO_READ)) {
3293                 free_btres(btv, fh, RESOURCE_VIDEO_READ);
3294         }
3295
3296         /* stop vbi capture */
3297         if (check_btres(fh, RESOURCE_VBI)) {
3298                 videobuf_stop(&fh->vbi);
3299                 free_btres(btv,fh,RESOURCE_VBI);
3300         }
3301
3302         /* free stuff */
3303         videobuf_mmap_free(&fh->cap);
3304         videobuf_mmap_free(&fh->vbi);
3305         v4l2_prio_close(&btv->prio,&fh->prio);
3306         file->private_data = NULL;
3307         kfree(fh);
3308
3309         btv->users--;
3310         bttv_field_count(btv);
3311
3312         if (!btv->users)
3313                 audio_mute(btv, 1);
3314
3315         return 0;
3316 }
3317
3318 static int
3319 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3320 {
3321         struct bttv_fh *fh = file->private_data;
3322
3323         dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3324                 fh->btv->c.nr, v4l2_type_names[fh->type],
3325                 vma->vm_start, vma->vm_end - vma->vm_start);
3326         return videobuf_mmap_mapper(bttv_queue(fh),vma);
3327 }
3328
3329 static const struct v4l2_file_operations bttv_fops =
3330 {
3331         .owner    = THIS_MODULE,
3332         .open     = bttv_open,
3333         .release  = bttv_release,
3334         .ioctl    = video_ioctl2,
3335         .read     = bttv_read,
3336         .mmap     = bttv_mmap,
3337         .poll     = bttv_poll,
3338 };
3339
3340 static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
3341         .vidioc_querycap                = bttv_querycap,
3342         .vidioc_enum_fmt_vid_cap        = bttv_enum_fmt_vid_cap,
3343         .vidioc_g_fmt_vid_cap           = bttv_g_fmt_vid_cap,
3344         .vidioc_try_fmt_vid_cap         = bttv_try_fmt_vid_cap,
3345         .vidioc_s_fmt_vid_cap           = bttv_s_fmt_vid_cap,
3346         .vidioc_enum_fmt_vid_overlay    = bttv_enum_fmt_vid_overlay,
3347         .vidioc_g_fmt_vid_overlay       = bttv_g_fmt_vid_overlay,
3348         .vidioc_try_fmt_vid_overlay     = bttv_try_fmt_vid_overlay,
3349         .vidioc_s_fmt_vid_overlay       = bttv_s_fmt_vid_overlay,
3350         .vidioc_g_fmt_vbi_cap           = bttv_g_fmt_vbi_cap,
3351         .vidioc_try_fmt_vbi_cap         = bttv_try_fmt_vbi_cap,
3352         .vidioc_s_fmt_vbi_cap           = bttv_s_fmt_vbi_cap,
3353         .vidioc_g_audio                 = bttv_g_audio,
3354         .vidioc_s_audio                 = bttv_s_audio,
3355         .vidioc_cropcap                 = bttv_cropcap,
3356         .vidioc_reqbufs                 = bttv_reqbufs,
3357         .vidioc_querybuf                = bttv_querybuf,
3358         .vidioc_qbuf                    = bttv_qbuf,
3359         .vidioc_dqbuf                   = bttv_dqbuf,
3360         .vidioc_s_std                   = bttv_s_std,
3361         .vidioc_enum_input              = bttv_enum_input,
3362         .vidioc_g_input                 = bttv_g_input,
3363         .vidioc_s_input                 = bttv_s_input,
3364         .vidioc_queryctrl               = bttv_queryctrl,
3365         .vidioc_g_ctrl                  = bttv_g_ctrl,
3366         .vidioc_s_ctrl                  = bttv_s_ctrl,
3367         .vidioc_streamon                = bttv_streamon,
3368         .vidioc_streamoff               = bttv_streamoff,
3369         .vidioc_g_tuner                 = bttv_g_tuner,
3370         .vidioc_s_tuner                 = bttv_s_tuner,
3371 #ifdef CONFIG_VIDEO_V4L1_COMPAT
3372         .vidiocgmbuf                    = vidiocgmbuf,
3373 #endif
3374         .vidioc_g_crop                  = bttv_g_crop,
3375         .vidioc_s_crop                  = bttv_s_crop,
3376         .vidioc_g_fbuf                  = bttv_g_fbuf,
3377         .vidioc_s_fbuf                  = bttv_s_fbuf,
3378         .vidioc_overlay                 = bttv_overlay,
3379         .vidioc_g_priority              = bttv_g_priority,
3380         .vidioc_s_priority              = bttv_s_priority,
3381         .vidioc_g_parm                  = bttv_g_parm,
3382         .vidioc_g_frequency             = bttv_g_frequency,
3383         .vidioc_s_frequency             = bttv_s_frequency,
3384         .vidioc_log_status              = bttv_log_status,
3385         .vidioc_querystd                = bttv_querystd,
3386 #ifdef CONFIG_VIDEO_ADV_DEBUG
3387         .vidioc_g_register              = bttv_g_register,
3388         .vidioc_s_register              = bttv_s_register,
3389 #endif
3390 };
3391
3392 static struct video_device bttv_video_template = {
3393         .fops         = &bttv_fops,
3394         .minor        = -1,
3395         .ioctl_ops    = &bttv_ioctl_ops,
3396         .tvnorms      = BTTV_NORMS,
3397         .current_norm = V4L2_STD_PAL,
3398 };
3399
3400 /* ----------------------------------------------------------------------- */
3401 /* radio interface                                                         */
3402
3403 static int radio_open(struct file *file)
3404 {
3405         int minor = video_devdata(file)->minor;
3406         struct bttv *btv = video_drvdata(file);
3407         struct bttv_fh *fh;
3408
3409         dprintk("bttv: open minor=%d\n",minor);
3410
3411         lock_kernel();
3412         WARN_ON(btv->radio_dev && btv->radio_dev->minor != minor);
3413         if (!btv->radio_dev || btv->radio_dev->minor != minor) {
3414                 unlock_kernel();
3415                 return -ENODEV;
3416         }
3417
3418         dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3419
3420         /* allocate per filehandle data */
3421         fh = kmalloc(sizeof(*fh), GFP_KERNEL);
3422         if (NULL == fh) {
3423                 unlock_kernel();
3424                 return -ENOMEM;
3425         }
3426         file->private_data = fh;
3427         *fh = btv->init;
3428         v4l2_prio_open(&btv->prio, &fh->prio);
3429
3430         mutex_lock(&btv->lock);
3431
3432         btv->radio_user++;
3433
3434         bttv_call_all(btv, tuner, s_radio);
3435         audio_input(btv,TVAUDIO_INPUT_RADIO);
3436
3437         mutex_unlock(&btv->lock);
3438         unlock_kernel();
3439         return 0;
3440 }
3441
3442 static int radio_release(struct file *file)
3443 {
3444         struct bttv_fh *fh = file->private_data;
3445         struct bttv *btv = fh->btv;
3446         struct rds_command cmd;
3447
3448         v4l2_prio_close(&btv->prio,&fh->prio);
3449         file->private_data = NULL;
3450         kfree(fh);
3451
3452         btv->radio_user--;
3453
3454         bttv_call_all(btv, core, ioctl, RDS_CMD_CLOSE, &cmd);
3455
3456         return 0;
3457 }
3458
3459 static int radio_querycap(struct file *file, void *priv,
3460                                         struct v4l2_capability *cap)
3461 {
3462         struct bttv_fh *fh = priv;
3463         struct bttv *btv = fh->btv;
3464
3465         strcpy(cap->driver, "bttv");
3466         strlcpy(cap->card, btv->radio_dev->name, sizeof(cap->card));
3467         sprintf(cap->bus_info, "PCI:%s", pci_name(btv->c.pci));
3468         cap->version = BTTV_VERSION_CODE;
3469         cap->capabilities = V4L2_CAP_TUNER;
3470
3471         return 0;
3472 }
3473
3474 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3475 {
3476         struct bttv_fh *fh = priv;
3477         struct bttv *btv = fh->btv;
3478
3479         if (btv->tuner_type == TUNER_ABSENT)
3480                 return -EINVAL;
3481         if (0 != t->index)
3482                 return -EINVAL;
3483         mutex_lock(&btv->lock);
3484         strcpy(t->name, "Radio");
3485         t->type = V4L2_TUNER_RADIO;
3486
3487         bttv_call_all(btv, tuner, g_tuner, t);
3488
3489         if (btv->audio_mode_gpio)
3490                 btv->audio_mode_gpio(btv, t, 0);
3491
3492         mutex_unlock(&btv->lock);
3493
3494         return 0;
3495 }
3496
3497 static int radio_enum_input(struct file *file, void *priv,
3498                                 struct v4l2_input *i)
3499 {
3500         if (i->index != 0)
3501                 return -EINVAL;
3502
3503         strcpy(i->name, "Radio");
3504         i->type = V4L2_INPUT_TYPE_TUNER;
3505
3506         return 0;
3507 }
3508
3509 static int radio_g_audio(struct file *file, void *priv,
3510                                         struct v4l2_audio *a)
3511 {
3512         if (unlikely(a->index))
3513                 return -EINVAL;
3514
3515         strcpy(a->name, "Radio");
3516
3517         return 0;
3518 }
3519
3520 static int radio_s_tuner(struct file *file, void *priv,
3521                                         struct v4l2_tuner *t)
3522 {
3523         struct bttv_fh *fh = priv;
3524         struct bttv *btv = fh->btv;
3525
3526         if (0 != t->index)
3527                 return -EINVAL;
3528
3529         bttv_call_all(btv, tuner, g_tuner, t);
3530         return 0;
3531 }
3532
3533 static int radio_s_audio(struct file *file, void *priv,
3534                                         struct v4l2_audio *a)
3535 {
3536         if (unlikely(a->index))
3537                 return -EINVAL;
3538
3539         return 0;
3540 }
3541
3542 static int radio_s_input(struct file *filp, void *priv, unsigned int i)
3543 {
3544         if (unlikely(i))
3545                 return -EINVAL;
3546
3547         return 0;
3548 }
3549
3550 static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
3551 {
3552         return 0;
3553 }
3554
3555 static int radio_queryctrl(struct file *file, void *priv,
3556                                         struct v4l2_queryctrl *c)
3557 {
3558         const struct v4l2_queryctrl *ctrl;
3559
3560         if (c->id <  V4L2_CID_BASE ||
3561                         c->id >= V4L2_CID_LASTP1)
3562                 return -EINVAL;
3563
3564         if (c->id == V4L2_CID_AUDIO_MUTE) {
3565                 ctrl = ctrl_by_id(c->id);
3566                 *c = *ctrl;
3567         } else
3568                 *c = no_ctl;
3569
3570         return 0;
3571 }
3572
3573 static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
3574 {
3575         *i = 0;
3576         return 0;
3577 }
3578
3579 static ssize_t radio_read(struct file *file, char __user *data,
3580                          size_t count, loff_t *ppos)
3581 {
3582         struct bttv_fh *fh = file->private_data;
3583         struct bttv *btv = fh->btv;
3584         struct rds_command cmd;
3585         cmd.block_count = count/3;
3586         cmd.buffer = data;
3587         cmd.instance = file;
3588         cmd.result = -ENODEV;
3589
3590         bttv_call_all(btv, core, ioctl, RDS_CMD_READ, &cmd);
3591
3592         return cmd.result;
3593 }
3594
3595 static unsigned int radio_poll(struct file *file, poll_table *wait)
3596 {
3597         struct bttv_fh *fh = file->private_data;
3598         struct bttv *btv = fh->btv;
3599         struct rds_command cmd;
3600         cmd.instance = file;
3601         cmd.event_list = wait;
3602         cmd.result = -ENODEV;
3603         bttv_call_all(btv, core, ioctl, RDS_CMD_POLL, &cmd);
3604
3605         return cmd.result;
3606 }
3607
3608 static const struct v4l2_file_operations radio_fops =
3609 {
3610         .owner    = THIS_MODULE,
3611         .open     = radio_open,
3612         .read     = radio_read,
3613         .release  = radio_release,
3614         .ioctl    = video_ioctl2,
3615         .poll     = radio_poll,
3616 };
3617
3618 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
3619         .vidioc_querycap        = radio_querycap,
3620         .vidioc_g_tuner         = radio_g_tuner,
3621         .vidioc_enum_input      = radio_enum_input,
3622         .vidioc_g_audio         = radio_g_audio,
3623         .vidioc_s_tuner         = radio_s_tuner,
3624         .vidioc_s_audio         = radio_s_audio,
3625         .vidioc_s_input         = radio_s_input,
3626         .vidioc_s_std           = radio_s_std,
3627         .vidioc_queryctrl       = radio_queryctrl,
3628         .vidioc_g_input         = radio_g_input,
3629         .vidioc_g_ctrl          = bttv_g_ctrl,
3630         .vidioc_s_ctrl          = bttv_s_ctrl,
3631         .vidioc_g_frequency     = bttv_g_frequency,
3632         .vidioc_s_frequency     = bttv_s_frequency,
3633 };
3634
3635 static struct video_device radio_template = {
3636         .fops      = &radio_fops,
3637         .minor     = -1,
3638         .ioctl_ops = &radio_ioctl_ops,
3639 };
3640
3641 /* ----------------------------------------------------------------------- */
3642 /* some debug code                                                         */
3643
3644 static int bttv_risc_decode(u32 risc)
3645 {
3646         static char *instr[16] = {
3647                 [ BT848_RISC_WRITE     >> 28 ] = "write",
3648                 [ BT848_RISC_SKIP      >> 28 ] = "skip",
3649                 [ BT848_RISC_WRITEC    >> 28 ] = "writec",
3650                 [ BT848_RISC_JUMP      >> 28 ] = "jump",
3651                 [ BT848_RISC_SYNC      >> 28 ] = "sync",
3652                 [ BT848_RISC_WRITE123  >> 28 ] = "write123",
3653                 [ BT848_RISC_SKIP123   >> 28 ] = "skip123",
3654                 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3655         };
3656         static int incr[16] = {
3657                 [ BT848_RISC_WRITE     >> 28 ] = 2,
3658                 [ BT848_RISC_JUMP      >> 28 ] = 2,
3659                 [ BT848_RISC_SYNC      >> 28 ] = 2,
3660                 [ BT848_RISC_WRITE123  >> 28 ] = 5,
3661                 [ BT848_RISC_SKIP123   >> 28 ] = 2,
3662                 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3663         };
3664         static char *bits[] = {
3665                 "be0",  "be1",  "be2",  "be3/resync",
3666                 "set0", "set1", "set2", "set3",
3667                 "clr0", "clr1", "clr2", "clr3",
3668                 "irq",  "res",  "eol",  "sol",
3669         };
3670         int i;
3671
3672         printk("0x%08x [ %s", risc,
3673                instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3674         for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3675                 if (risc & (1 << (i + 12)))
3676                         printk(" %s",bits[i]);
3677         printk(" count=%d ]\n", risc & 0xfff);
3678         return incr[risc >> 28] ? incr[risc >> 28] : 1;
3679 }
3680
3681 static void bttv_risc_disasm(struct bttv *btv,
3682                              struct btcx_riscmem *risc)
3683 {
3684         unsigned int i,j,n;
3685
3686         printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3687                btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma);
3688         for (i = 0; i < (risc->size >> 2); i += n) {
3689                 printk("%s:   0x%lx: ", btv->c.v4l2_dev.name,
3690                        (unsigned long)(risc->dma + (i<<2)));
3691                 n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
3692                 for (j = 1; j < n; j++)
3693                         printk("%s:   0x%lx: 0x%08x [ arg #%d ]\n",
3694                                btv->c.v4l2_dev.name, (unsigned long)(risc->dma + ((i+j)<<2)),
3695                                risc->cpu[i+j], j);
3696                 if (0 == risc->cpu[i])
3697                         break;
3698         }
3699 }
3700
3701 static void bttv_print_riscaddr(struct bttv *btv)
3702 {
3703         printk("  main: %08Lx\n",
3704                (unsigned long long)btv->main.dma);
3705         printk("  vbi : o=%08Lx e=%08Lx\n",
3706                btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3707                btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3708         printk("  cap : o=%08Lx e=%08Lx\n",
3709                btv->curr.top    ? (unsigned long long)btv->curr.top->top.dma : 0,
3710                btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3711         printk("  scr : o=%08Lx e=%08Lx\n",
3712                btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3713                btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3714         bttv_risc_disasm(btv, &btv->main);
3715 }
3716
3717 /* ----------------------------------------------------------------------- */
3718 /* irq handler                                                             */
3719
3720 static char *irq_name[] = {
3721         "FMTCHG",  // format change detected (525 vs. 625)
3722         "VSYNC",   // vertical sync (new field)
3723         "HSYNC",   // horizontal sync
3724         "OFLOW",   // chroma/luma AGC overflow
3725         "HLOCK",   // horizontal lock changed
3726         "VPRES",   // video presence changed
3727         "6", "7",
3728         "I2CDONE", // hw irc operation finished
3729         "GPINT",   // gpio port triggered irq
3730         "10",
3731         "RISCI",   // risc instruction triggered irq
3732         "FBUS",    // pixel data fifo dropped data (high pci bus latencies)
3733         "FTRGT",   // pixel data fifo overrun
3734         "FDSR",    // fifo data stream resyncronisation
3735         "PPERR",   // parity error (data transfer)
3736         "RIPERR",  // parity error (read risc instructions)
3737         "PABORT",  // pci abort
3738         "OCERR",   // risc instruction error
3739         "SCERR",   // syncronisation error
3740 };
3741
3742 static void bttv_print_irqbits(u32 print, u32 mark)
3743 {
3744         unsigned int i;
3745
3746         printk("bits:");
3747         for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3748                 if (print & (1 << i))
3749                         printk(" %s",irq_name[i]);
3750                 if (mark & (1 << i))
3751                         printk("*");
3752         }
3753 }
3754
3755 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3756 {
3757         printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3758                btv->c.nr,
3759                (unsigned long)btv->main.dma,
3760                (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
3761                (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
3762                (unsigned long)rc);
3763
3764         if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3765                 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3766                        "Ok, then this is harmless, don't worry ;)\n",
3767                        btv->c.nr);
3768                 return;
3769         }
3770         printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3771                btv->c.nr);
3772         printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3773                btv->c.nr);
3774         dump_stack();
3775 }
3776
3777 static int
3778 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3779 {
3780         struct bttv_buffer *item;
3781
3782         memset(set,0,sizeof(*set));
3783
3784         /* capture request ? */
3785         if (!list_empty(&btv->capture)) {
3786                 set->frame_irq = 1;
3787                 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3788                 if (V4L2_FIELD_HAS_TOP(item->vb.field))
3789                         set->top    = item;
3790                 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3791                         set->bottom = item;
3792
3793                 /* capture request for other field ? */
3794                 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3795                     (item->vb.queue.next != &btv->capture)) {
3796                         item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3797                         if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3798                                 if (NULL == set->top &&
3799                                     V4L2_FIELD_TOP == item->vb.field) {
3800                                         set->top = item;
3801                                 }
3802                                 if (NULL == set->bottom &&
3803                                     V4L2_FIELD_BOTTOM == item->vb.field) {
3804                                         set->bottom = item;
3805                                 }
3806                                 if (NULL != set->top  &&  NULL != set->bottom)
3807                                         set->top_irq = 2;
3808                         }
3809                 }
3810         }
3811
3812         /* screen overlay ? */
3813         if (NULL != btv->screen) {
3814                 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3815                         if (NULL == set->top && NULL == set->bottom) {
3816                                 set->top    = btv->screen;
3817                                 set->bottom = btv->screen;
3818                         }
3819                 } else {
3820                         if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3821                             NULL == set->top) {
3822                                 set->top = btv->screen;
3823                         }
3824                         if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3825                             NULL == set->bottom) {
3826                                 set->bottom = btv->screen;
3827                         }
3828                 }
3829         }
3830
3831         dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3832                 btv->c.nr,set->top, set->bottom,
3833                 btv->screen,set->frame_irq,set->top_irq);
3834         return 0;
3835 }
3836
3837 static void
3838 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3839                       struct bttv_buffer_set *curr, unsigned int state)
3840 {
3841         struct timeval ts;
3842
3843         do_gettimeofday(&ts);
3844
3845         if (wakeup->top == wakeup->bottom) {
3846                 if (NULL != wakeup->top && curr->top != wakeup->top) {
3847                         if (irq_debug > 1)
3848                                 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
3849                         wakeup->top->vb.ts = ts;
3850                         wakeup->top->vb.field_count = btv->field_count;
3851                         wakeup->top->vb.state = state;
3852                         wake_up(&wakeup->top->vb.done);
3853                 }
3854         } else {
3855                 if (NULL != wakeup->top && curr->top != wakeup->top) {
3856                         if (irq_debug > 1)
3857                                 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
3858                         wakeup->top->vb.ts = ts;
3859                         wakeup->top->vb.field_count = btv->field_count;
3860                         wakeup->top->vb.state = state;
3861                         wake_up(&wakeup->top->vb.done);
3862                 }
3863                 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3864                         if (irq_debug > 1)
3865                                 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
3866                         wakeup->bottom->vb.ts = ts;
3867                         wakeup->bottom->vb.field_count = btv->field_count;
3868                         wakeup->bottom->vb.state = state;
3869                         wake_up(&wakeup->bottom->vb.done);
3870                 }
3871         }
3872 }
3873
3874 static void
3875 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3876                     unsigned int state)
3877 {
3878         struct timeval ts;
3879
3880         if (NULL == wakeup)
3881                 return;
3882
3883         do_gettimeofday(&ts);
3884         wakeup->vb.ts = ts;
3885         wakeup->vb.field_count = btv->field_count;
3886         wakeup->vb.state = state;
3887         wake_up(&wakeup->vb.done);
3888 }
3889
3890 static void bttv_irq_timeout(unsigned long data)
3891 {
3892         struct bttv *btv = (struct bttv *)data;
3893         struct bttv_buffer_set old,new;
3894         struct bttv_buffer *ovbi;
3895         struct bttv_buffer *item;
3896         unsigned long flags;
3897
3898         if (bttv_verbose) {
3899                 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3900                        btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3901                        btread(BT848_RISC_COUNT));
3902                 bttv_print_irqbits(btread(BT848_INT_STAT),0);
3903                 printk("\n");
3904         }
3905
3906         spin_lock_irqsave(&btv->s_lock,flags);
3907
3908         /* deactivate stuff */
3909         memset(&new,0,sizeof(new));
3910         old  = btv->curr;
3911         ovbi = btv->cvbi;
3912         btv->curr = new;
3913         btv->cvbi = NULL;
3914         btv->loop_irq = 0;
3915         bttv_buffer_activate_video(btv, &new);
3916         bttv_buffer_activate_vbi(btv,   NULL);
3917         bttv_set_dma(btv, 0);
3918
3919         /* wake up */
3920         bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
3921         bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
3922
3923         /* cancel all outstanding capture / vbi requests */
3924         while (!list_empty(&btv->capture)) {
3925                 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3926                 list_del(&item->vb.queue);
3927                 item->vb.state = VIDEOBUF_ERROR;
3928                 wake_up(&item->vb.done);
3929         }
3930         while (!list_empty(&btv->vcapture)) {
3931                 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3932                 list_del(&item->vb.queue);
3933                 item->vb.state = VIDEOBUF_ERROR;
3934                 wake_up(&item->vb.done);
3935         }
3936
3937         btv->errors++;
3938         spin_unlock_irqrestore(&btv->s_lock,flags);
3939 }
3940
3941 static void
3942 bttv_irq_wakeup_top(struct bttv *btv)
3943 {
3944         struct bttv_buffer *wakeup = btv->curr.top;
3945
3946         if (NULL == wakeup)
3947                 return;
3948
3949         spin_lock(&btv->s_lock);
3950         btv->curr.top_irq = 0;
3951         btv->curr.top = NULL;
3952         bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3953
3954         do_gettimeofday(&wakeup->vb.ts);
3955         wakeup->vb.field_count = btv->field_count;
3956         wakeup->vb.state = VIDEOBUF_DONE;
3957         wake_up(&wakeup->vb.done);
3958         spin_unlock(&btv->s_lock);
3959 }
3960
3961 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
3962 {
3963         if (rc < risc->dma)
3964                 return 0;
3965         if (rc > risc->dma + risc->size)
3966                 return 0;
3967         return 1;
3968 }
3969
3970 static void
3971 bttv_irq_switch_video(struct bttv *btv)
3972 {
3973         struct bttv_buffer_set new;
3974         struct bttv_buffer_set old;
3975         dma_addr_t rc;
3976
3977         spin_lock(&btv->s_lock);
3978
3979         /* new buffer set */
3980         bttv_irq_next_video(btv, &new);
3981         rc = btread(BT848_RISC_COUNT);
3982         if ((btv->curr.top    && is_active(&btv->curr.top->top,       rc)) ||
3983             (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
3984                 btv->framedrop++;
3985                 if (debug_latency)
3986                         bttv_irq_debug_low_latency(btv, rc);
3987                 spin_unlock(&btv->s_lock);
3988                 return;
3989         }
3990
3991         /* switch over */
3992         old = btv->curr;
3993         btv->curr = new;
3994         btv->loop_irq &= ~1;
3995         bttv_buffer_activate_video(btv, &new);
3996         bttv_set_dma(btv, 0);
3997
3998         /* switch input */
3999         if (UNSET != btv->new_input) {
4000                 video_mux(btv,btv->new_input);
4001                 btv->new_input = UNSET;
4002         }
4003
4004         /* wake up finished buffers */
4005         bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
4006         spin_unlock(&btv->s_lock);
4007 }
4008
4009 static void
4010 bttv_irq_switch_vbi(struct bttv *btv)
4011 {
4012         struct bttv_buffer *new = NULL;
4013         struct bttv_buffer *old;
4014         u32 rc;
4015
4016         spin_lock(&btv->s_lock);
4017
4018         if (!list_empty(&btv->vcapture))
4019                 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4020         old = btv->cvbi;
4021
4022         rc = btread(BT848_RISC_COUNT);
4023         if (NULL != old && (is_active(&old->top,    rc) ||
4024                             is_active(&old->bottom, rc))) {
4025                 btv->framedrop++;
4026                 if (debug_latency)
4027                         bttv_irq_debug_low_latency(btv, rc);
4028                 spin_unlock(&btv->s_lock);
4029                 return;
4030         }
4031
4032         /* switch */
4033         btv->cvbi = new;
4034         btv->loop_irq &= ~4;
4035         bttv_buffer_activate_vbi(btv, new);
4036         bttv_set_dma(btv, 0);
4037
4038         bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
4039         spin_unlock(&btv->s_lock);
4040 }
4041
4042 static irqreturn_t bttv_irq(int irq, void *dev_id)
4043 {
4044         u32 stat,astat;
4045         u32 dstat;
4046         int count;
4047         struct bttv *btv;
4048         int handled = 0;
4049
4050         btv=(struct bttv *)dev_id;
4051
4052         if (btv->custom_irq)
4053                 handled = btv->custom_irq(btv);
4054
4055         count=0;
4056         while (1) {
4057                 /* get/clear interrupt status bits */
4058                 stat=btread(BT848_INT_STAT);
4059                 astat=stat&btread(BT848_INT_MASK);
4060                 if (!astat)
4061                         break;
4062                 handled = 1;
4063                 btwrite(stat,BT848_INT_STAT);
4064
4065                 /* get device status bits */
4066                 dstat=btread(BT848_DSTATUS);
4067
4068                 if (irq_debug) {
4069                         printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
4070                                "riscs=%x, riscc=%08x, ",
4071                                btv->c.nr, count, btv->field_count,
4072                                stat>>28, btread(BT848_RISC_COUNT));
4073                         bttv_print_irqbits(stat,astat);
4074                         if (stat & BT848_INT_HLOCK)
4075                                 printk("   HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
4076                                        ? "yes" : "no");
4077                         if (stat & BT848_INT_VPRES)
4078                                 printk("   PRES => %s", (dstat & BT848_DSTATUS_PRES)
4079                                        ? "yes" : "no");
4080                         if (stat & BT848_INT_FMTCHG)
4081                                 printk("   NUML => %s", (dstat & BT848_DSTATUS_NUML)
4082                                        ? "625" : "525");
4083                         printk("\n");
4084                 }
4085
4086                 if (astat&BT848_INT_VSYNC)
4087                         btv->field_count++;
4088
4089                 if ((astat & BT848_INT_GPINT) && btv->remote) {
4090                         wake_up(&btv->gpioq);
4091                         bttv_input_irq(btv);
4092                 }
4093
4094                 if (astat & BT848_INT_I2CDONE) {
4095                         btv->i2c_done = stat;
4096                         wake_up(&btv->i2c_queue);
4097                 }
4098
4099                 if ((astat & BT848_INT_RISCI)  &&  (stat & (4<<28)))
4100                         bttv_irq_switch_vbi(btv);
4101
4102                 if ((astat & BT848_INT_RISCI)  &&  (stat & (2<<28)))
4103                         bttv_irq_wakeup_top(btv);
4104
4105                 if ((astat & BT848_INT_RISCI)  &&  (stat & (1<<28)))
4106                         bttv_irq_switch_video(btv);
4107
4108                 if ((astat & BT848_INT_HLOCK)  &&  btv->opt_automute)
4109                         audio_mute(btv, btv->mute);  /* trigger automute */
4110
4111                 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
4112                         printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
4113                                (astat & BT848_INT_SCERR) ? "SCERR" : "",
4114                                (astat & BT848_INT_OCERR) ? "OCERR" : "",
4115                                btread(BT848_RISC_COUNT));
4116                         bttv_print_irqbits(stat,astat);
4117                         printk("\n");
4118                         if (bttv_debug)
4119                                 bttv_print_riscaddr(btv);
4120                 }
4121                 if (fdsr && astat & BT848_INT_FDSR) {
4122                         printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
4123                                btv->c.nr,btread(BT848_RISC_COUNT));
4124                         if (bttv_debug)
4125                                 bttv_print_riscaddr(btv);
4126                 }
4127
4128                 count++;
4129                 if (count > 4) {
4130
4131                         if (count > 8 || !(astat & BT848_INT_GPINT)) {
4132                                 btwrite(0, BT848_INT_MASK);
4133
4134                                 printk(KERN_ERR
4135                                            "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
4136                         } else {
4137                                 printk(KERN_ERR
4138                                            "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
4139
4140                                 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
4141                                                 BT848_INT_MASK);
4142                         };
4143
4144                         bttv_print_irqbits(stat,astat);
4145
4146                         printk("]\n");
4147                 }
4148         }
4149         btv->irq_total++;
4150         if (handled)
4151                 btv->irq_me++;
4152         return IRQ_RETVAL(handled);
4153 }
4154
4155
4156 /* ----------------------------------------------------------------------- */
4157 /* initialitation                                                          */
4158
4159 static struct video_device *vdev_init(struct bttv *btv,
4160                                       const struct video_device *template,
4161                                       const char *type_name)
4162 {
4163         struct video_device *vfd;
4164
4165         vfd = video_device_alloc();
4166         if (NULL == vfd)
4167                 return NULL;
4168         *vfd = *template;
4169         vfd->minor   = -1;
4170         vfd->v4l2_dev = &btv->c.v4l2_dev;
4171         vfd->release = video_device_release;
4172         vfd->debug   = bttv_debug;
4173         video_set_drvdata(vfd, btv);
4174         snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
4175                  btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
4176                  type_name, bttv_tvcards[btv->c.type].name);
4177         return vfd;
4178 }
4179
4180 static void bttv_unregister_video(struct bttv *btv)
4181 {
4182         if (btv->video_dev) {
4183                 if (-1 != btv->video_dev->minor)
4184                         video_unregister_device(btv->video_dev);
4185                 else
4186                         video_device_release(btv->video_dev);
4187                 btv->video_dev = NULL;
4188         }
4189         if (btv->vbi_dev) {
4190                 if (-1 != btv->vbi_dev->minor)
4191                         video_unregister_device(btv->vbi_dev);
4192                 else
4193                         video_device_release(btv->vbi_dev);
4194                 btv->vbi_dev = NULL;
4195         }
4196         if (btv->radio_dev) {
4197                 if (-1 != btv->radio_dev->minor)
4198                         video_unregister_device(btv->radio_dev);
4199                 else
4200                         video_device_release(btv->radio_dev);
4201                 btv->radio_dev = NULL;
4202         }
4203 }
4204
4205 /* register video4linux devices */
4206 static int __devinit bttv_register_video(struct bttv *btv)
4207 {
4208         if (no_overlay > 0)
4209                 printk("bttv: Overlay support disabled.\n");
4210
4211         /* video */
4212         btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
4213
4214         if (NULL == btv->video_dev)
4215                 goto err;
4216         if (video_register_device(btv->video_dev, VFL_TYPE_GRABBER,
4217                                   video_nr[btv->c.nr]) < 0)
4218                 goto err;
4219         printk(KERN_INFO "bttv%d: registered device video%d\n",
4220                btv->c.nr, btv->video_dev->num);
4221         if (device_create_file(&btv->video_dev->dev,
4222                                      &dev_attr_card)<0) {
4223                 printk(KERN_ERR "bttv%d: device_create_file 'card' "
4224                        "failed\n", btv->c.nr);
4225                 goto err;
4226         }
4227
4228         /* vbi */
4229         btv->vbi_dev = vdev_init(btv, &bttv_video_template, "vbi");
4230
4231         if (NULL == btv->vbi_dev)
4232                 goto err;
4233         if (video_register_device(btv->vbi_dev, VFL_TYPE_VBI,
4234                                   vbi_nr[btv->c.nr]) < 0)
4235                 goto err;
4236         printk(KERN_INFO "bttv%d: registered device vbi%d\n",
4237                btv->c.nr, btv->vbi_dev->num);
4238
4239         if (!btv->has_radio)
4240                 return 0;
4241         /* radio */
4242         btv->radio_dev = vdev_init(btv, &radio_template, "radio");
4243         if (NULL == btv->radio_dev)
4244                 goto err;
4245         if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,
4246                                   radio_nr[btv->c.nr]) < 0)
4247                 goto err;
4248         printk(KERN_INFO "bttv%d: registered device radio%d\n",
4249                btv->c.nr, btv->radio_dev->num);
4250
4251         /* all done */
4252         return 0;
4253
4254  err:
4255         bttv_unregister_video(btv);
4256         return -1;
4257 }
4258
4259
4260 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
4261 /* response on cards with no firmware is not enabled by OF */
4262 static void pci_set_command(struct pci_dev *dev)
4263 {
4264 #if defined(__powerpc__)
4265         unsigned int cmd;
4266
4267         pci_read_config_dword(dev, PCI_COMMAND, &cmd);
4268         cmd = (cmd | PCI_COMMAND_MEMORY );
4269         pci_write_config_dword(dev, PCI_COMMAND, cmd);
4270 #endif
4271 }
4272
4273 static int __devinit bttv_probe(struct pci_dev *dev,
4274                                 const struct pci_device_id *pci_id)
4275 {
4276         int result;
4277         unsigned char lat;
4278         struct bttv *btv;
4279
4280         if (bttv_num == BTTV_MAX)
4281                 return -ENOMEM;
4282         printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
4283         bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL);
4284         if (btv == NULL) {
4285                 printk(KERN_ERR "bttv: out of memory.\n");
4286                 return -ENOMEM;
4287         }
4288         btv->c.nr  = bttv_num;
4289         snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name),
4290                         "bttv%d", btv->c.nr);
4291
4292         /* initialize structs / fill in defaults */
4293         mutex_init(&btv->lock);
4294         spin_lock_init(&btv->s_lock);
4295         spin_lock_init(&btv->gpio_lock);
4296         init_waitqueue_head(&btv->gpioq);
4297         init_waitqueue_head(&btv->i2c_queue);
4298         INIT_LIST_HEAD(&btv->c.subs);
4299         INIT_LIST_HEAD(&btv->capture);
4300         INIT_LIST_HEAD(&btv->vcapture);
4301         v4l2_prio_init(&btv->prio);
4302
4303         init_timer(&btv->timeout);
4304         btv->timeout.function = bttv_irq_timeout;
4305         btv->timeout.data     = (unsigned long)btv;
4306
4307         btv->i2c_rc = -1;
4308         btv->tuner_type  = UNSET;
4309         btv->new_input   = UNSET;
4310         btv->has_radio=radio[btv->c.nr];
4311
4312         /* pci stuff (init, get irq/mmio, ... */
4313         btv->c.pci = dev;
4314         btv->id  = dev->device;
4315         if (pci_enable_device(dev)) {
4316                 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4317                        btv->c.nr);
4318                 return -EIO;
4319         }
4320         if (pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
4321                 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
4322                        btv->c.nr);
4323                 return -EIO;
4324         }
4325         if (!request_mem_region(pci_resource_start(dev,0),
4326                                 pci_resource_len(dev,0),
4327                                 btv->c.v4l2_dev.name)) {
4328                 printk(KERN_WARNING "bttv%d: can't request iomem (0x%llx).\n",
4329                        btv->c.nr,
4330                        (unsigned long long)pci_resource_start(dev,0));
4331                 return -EBUSY;
4332         }
4333         pci_set_master(dev);
4334         pci_set_command(dev);
4335
4336         result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev);
4337         if (result < 0) {
4338                 printk(KERN_WARNING "bttv%d: v4l2_device_register() failed\n", btv->c.nr);
4339                 goto fail0;
4340         }
4341
4342         pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
4343         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4344         printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
4345                bttv_num,btv->id, btv->revision, pci_name(dev));
4346         printk("irq: %d, latency: %d, mmio: 0x%llx\n",
4347                btv->c.pci->irq, lat,
4348                (unsigned long long)pci_resource_start(dev,0));
4349         schedule();
4350
4351         btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4352         if (NULL == btv->bt848_mmio) {
4353                 printk("bttv%d: ioremap() failed\n", btv->c.nr);
4354                 result = -EIO;
4355                 goto fail1;
4356         }
4357
4358         /* identify card */
4359         bttv_idcard(btv);
4360
4361         /* disable irqs, register irq handler */
4362         btwrite(0, BT848_INT_MASK);
4363         result = request_irq(btv->c.pci->irq, bttv_irq,
4364             IRQF_SHARED | IRQF_DISABLED, btv->c.v4l2_dev.name, (void *)btv);
4365         if (result < 0) {
4366                 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
4367                        bttv_num,btv->c.pci->irq);
4368                 goto fail1;
4369         }
4370
4371         if (0 != bttv_handle_chipset(btv)) {
4372                 result = -EIO;
4373                 goto fail2;
4374         }
4375
4376         /* init options from insmod args */
4377         btv->opt_combfilter = combfilter;
4378         btv->opt_lumafilter = lumafilter;
4379         btv->opt_automute   = automute;
4380         btv->opt_chroma_agc = chroma_agc;
4381         btv->opt_adc_crush  = adc_crush;
4382         btv->opt_vcr_hack   = vcr_hack;
4383         btv->opt_whitecrush_upper  = whitecrush_upper;
4384         btv->opt_whitecrush_lower  = whitecrush_lower;
4385         btv->opt_uv_ratio   = uv_ratio;
4386         btv->opt_full_luma_range   = full_luma_range;
4387         btv->opt_coring     = coring;
4388
4389         /* fill struct bttv with some useful defaults */
4390         btv->init.btv         = btv;
4391         btv->init.ov.w.width  = 320;
4392         btv->init.ov.w.height = 240;
4393         btv->init.fmt         = format_by_fourcc(V4L2_PIX_FMT_BGR24);
4394         btv->init.width       = 320;
4395         btv->init.height      = 240;
4396         btv->input = 0;
4397
4398         /* initialize hardware */
4399         if (bttv_gpio)
4400                 bttv_gpio_tracking(btv,"pre-init");
4401
4402         bttv_risc_init_main(btv);
4403         init_bt848(btv);
4404
4405         /* gpio */
4406         btwrite(0x00, BT848_GPIO_REG_INP);
4407         btwrite(0x00, BT848_GPIO_OUT_EN);
4408         if (bttv_verbose)
4409                 bttv_gpio_tracking(btv,"init");
4410
4411         /* needs to be done before i2c is registered */
4412         bttv_init_card1(btv);
4413
4414         /* register i2c + gpio */
4415         init_bttv_i2c(btv);
4416
4417         /* some card-specific stuff (needs working i2c) */
4418         bttv_init_card2(btv);
4419         init_irqreg(btv);
4420
4421         /* register video4linux + input */
4422         if (!bttv_tvcards[btv->c.type].no_video) {
4423                 bttv_register_video(btv);
4424                 bt848_bright(btv,32768);
4425                 bt848_contrast(btv,32768);
4426                 bt848_hue(btv,32768);
4427                 bt848_sat(btv,32768);
4428                 audio_mute(btv, 1);
4429                 set_input(btv, 0, btv->tvnorm);
4430                 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4431                 btv->crop[1] = btv->crop[0]; /* current = default */
4432                 disclaim_vbi_lines(btv);
4433                 disclaim_video_lines(btv);
4434         }
4435
4436         /* add subdevices and autoload dvb-bt8xx if needed */
4437         if (bttv_tvcards[btv->c.type].has_dvb) {
4438                 bttv_sub_add_device(&btv->c, "dvb");
4439                 request_modules(btv);
4440         }
4441
4442         bttv_input_init(btv);
4443
4444         /* everything is fine */
4445         bttv_num++;
4446         return 0;
4447
4448 fail2:
4449         free_irq(btv->c.pci->irq,btv);
4450
4451 fail1:
4452         v4l2_device_unregister(&btv->c.v4l2_dev);
4453
4454 fail0:
4455         if (btv->bt848_mmio)
4456                 iounmap(btv->bt848_mmio);
4457         release_mem_region(pci_resource_start(btv->c.pci,0),
4458                            pci_resource_len(btv->c.pci,0));
4459         return result;
4460 }
4461
4462 static void __devexit bttv_remove(struct pci_dev *pci_dev)
4463 {
4464         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4465         struct bttv *btv = to_bttv(v4l2_dev);
4466
4467         if (bttv_verbose)
4468                 printk("bttv%d: unloading\n",btv->c.nr);
4469
4470         /* shutdown everything (DMA+IRQs) */
4471         btand(~15, BT848_GPIO_DMA_CTL);
4472         btwrite(0, BT848_INT_MASK);
4473         btwrite(~0x0, BT848_INT_STAT);
4474         btwrite(0x0, BT848_GPIO_OUT_EN);
4475         if (bttv_gpio)
4476                 bttv_gpio_tracking(btv,"cleanup");
4477
4478         /* tell gpio modules we are leaving ... */
4479         btv->shutdown=1;
4480         wake_up(&btv->gpioq);
4481         bttv_input_fini(btv);
4482         bttv_sub_del_devices(&btv->c);
4483
4484         /* unregister i2c_bus + input */
4485         fini_bttv_i2c(btv);
4486
4487         /* unregister video4linux */
4488         bttv_unregister_video(btv);
4489
4490         /* free allocated memory */
4491         btcx_riscmem_free(btv->c.pci,&btv->main);
4492
4493         /* free ressources */
4494         free_irq(btv->c.pci->irq,btv);
4495         iounmap(btv->bt848_mmio);
4496         release_mem_region(pci_resource_start(btv->c.pci,0),
4497                            pci_resource_len(btv->c.pci,0));
4498
4499         v4l2_device_unregister(&btv->c.v4l2_dev);
4500         bttvs[btv->c.nr] = NULL;
4501         kfree(btv);
4502
4503         return;
4504 }
4505
4506 #ifdef CONFIG_PM
4507 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4508 {
4509         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4510         struct bttv *btv = to_bttv(v4l2_dev);
4511         struct bttv_buffer_set idle;
4512         unsigned long flags;
4513
4514         dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
4515
4516         /* stop dma + irqs */
4517         spin_lock_irqsave(&btv->s_lock,flags);
4518         memset(&idle, 0, sizeof(idle));
4519         btv->state.video = btv->curr;
4520         btv->state.vbi   = btv->cvbi;
4521         btv->state.loop_irq = btv->loop_irq;
4522         btv->curr = idle;
4523         btv->loop_irq = 0;
4524         bttv_buffer_activate_video(btv, &idle);
4525         bttv_buffer_activate_vbi(btv, NULL);
4526         bttv_set_dma(btv, 0);
4527         btwrite(0, BT848_INT_MASK);
4528         spin_unlock_irqrestore(&btv->s_lock,flags);
4529
4530         /* save bt878 state */
4531         btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4532         btv->state.gpio_data   = gpio_read();
4533
4534         /* save pci state */
4535         pci_save_state(pci_dev);
4536         if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4537                 pci_disable_device(pci_dev);
4538                 btv->state.disabled = 1;
4539         }
4540         return 0;
4541 }
4542
4543 static int bttv_resume(struct pci_dev *pci_dev)
4544 {
4545         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4546         struct bttv *btv = to_bttv(v4l2_dev);
4547         unsigned long flags;
4548         int err;
4549
4550         dprintk("bttv%d: resume\n", btv->c.nr);
4551
4552         /* restore pci state */
4553         if (btv->state.disabled) {
4554                 err=pci_enable_device(pci_dev);
4555                 if (err) {
4556                         printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4557                                                                 btv->c.nr);
4558                         return err;
4559                 }
4560                 btv->state.disabled = 0;
4561         }
4562         err=pci_set_power_state(pci_dev, PCI_D0);
4563         if (err) {
4564                 pci_disable_device(pci_dev);
4565                 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4566                                                         btv->c.nr);
4567                 btv->state.disabled = 1;
4568                 return err;
4569         }
4570
4571         pci_restore_state(pci_dev);
4572
4573         /* restore bt878 state */
4574         bttv_reinit_bt848(btv);
4575         gpio_inout(0xffffff, btv->state.gpio_enable);
4576         gpio_write(btv->state.gpio_data);
4577
4578         /* restart dma */
4579         spin_lock_irqsave(&btv->s_lock,flags);
4580         btv->curr = btv->state.video;
4581         btv->cvbi = btv->state.vbi;
4582         btv->loop_irq = btv->state.loop_irq;
4583         bttv_buffer_activate_video(btv, &btv->curr);
4584         bttv_buffer_activate_vbi(btv, btv->cvbi);
4585         bttv_set_dma(btv, 0);
4586         spin_unlock_irqrestore(&btv->s_lock,flags);
4587         return 0;
4588 }
4589 #endif
4590
4591 static struct pci_device_id bttv_pci_tbl[] = {
4592         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
4593          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4594         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
4595          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4596         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
4597          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4598         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
4599          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4600         {0,}
4601 };
4602
4603 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4604
4605 static struct pci_driver bttv_pci_driver = {
4606         .name     = "bttv",
4607         .id_table = bttv_pci_tbl,
4608         .probe    = bttv_probe,
4609         .remove   = __devexit_p(bttv_remove),
4610 #ifdef CONFIG_PM
4611         .suspend  = bttv_suspend,
4612         .resume   = bttv_resume,
4613 #endif
4614 };
4615
4616 static int __init bttv_init_module(void)
4617 {
4618         int ret;
4619
4620         bttv_num = 0;
4621
4622         printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4623                (BTTV_VERSION_CODE >> 16) & 0xff,
4624                (BTTV_VERSION_CODE >> 8) & 0xff,
4625                BTTV_VERSION_CODE & 0xff);
4626 #ifdef SNAPSHOT
4627         printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4628                SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4629 #endif
4630         if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4631                 gbuffers = 2;
4632         if (gbufsize < 0 || gbufsize > BTTV_MAX_FBUF)
4633                 gbufsize = BTTV_MAX_FBUF;
4634         gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4635         if (bttv_verbose)
4636                 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4637                        gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4638
4639         bttv_check_chipset();
4640
4641         ret = bus_register(&bttv_sub_bus_type);
4642         if (ret < 0) {
4643                 printk(KERN_WARNING "bttv: bus_register error: %d\n", ret);
4644                 return ret;
4645         }
4646         ret = pci_register_driver(&bttv_pci_driver);
4647         if (ret < 0)
4648                 bus_unregister(&bttv_sub_bus_type);
4649
4650         return ret;
4651 }
4652
4653 static void __exit bttv_cleanup_module(void)
4654 {
4655         pci_unregister_driver(&bttv_pci_driver);
4656         bus_unregister(&bttv_sub_bus_type);
4657 }
4658
4659 module_init(bttv_init_module);
4660 module_exit(bttv_cleanup_module);
4661
4662 /*
4663  * Local variables:
4664  * c-basic-offset: 8
4665  * End:
4666  */