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

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