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