SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/bt8xx/bttv-driver.c

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