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         if (*size * *count > gbuffers * gbufsize)
1810                 *count = (gbuffers * gbufsize) / *size;
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
1991         f->type = btv->radio_user ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1992         f->frequency = btv->freq;
1993
1994         return 0;
1995 }
1996
1997 static int bttv_s_frequency(struct file *file, void *priv,
1998                                         struct v4l2_frequency *f)
1999 {
2000         struct bttv_fh *fh  = priv;
2001         struct bttv *btv = fh->btv;
2002         int err;
2003
2004         err = v4l2_prio_check(&btv->prio, fh->prio);
2005         if (0 != err)
2006                 return err;
2007
2008         if (unlikely(f->tuner != 0))
2009                 return -EINVAL;
2010         if (unlikely(f->type != (btv->radio_user
2011                 ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV)))
2012                 return -EINVAL;
2013         mutex_lock(&btv->lock);
2014         btv->freq = f->frequency;
2015         bttv_call_all(btv, tuner, s_frequency, f);
2016         if (btv->has_matchbox && btv->radio_user)
2017                 tea5757_set_freq(btv, btv->freq);
2018         mutex_unlock(&btv->lock);
2019         return 0;
2020 }
2021
2022 static int bttv_log_status(struct file *file, void *f)
2023 {
2024         struct bttv_fh *fh  = f;
2025         struct bttv *btv = fh->btv;
2026
2027         printk(KERN_INFO "bttv%d: ========  START STATUS CARD #%d  ========\n",
2028                         btv->c.nr, btv->c.nr);
2029         bttv_call_all(btv, core, log_status);
2030         printk(KERN_INFO "bttv%d: ========  END STATUS CARD   #%d  ========\n",
2031                         btv->c.nr, btv->c.nr);
2032         return 0;
2033 }
2034
2035 #ifdef CONFIG_VIDEO_ADV_DEBUG
2036 static int bttv_g_register(struct file *file, void *f,
2037                                         struct v4l2_dbg_register *reg)
2038 {
2039         struct bttv_fh *fh = f;
2040         struct bttv *btv = fh->btv;
2041
2042         if (!capable(CAP_SYS_ADMIN))
2043                 return -EPERM;
2044
2045         if (!v4l2_chip_match_host(&reg->match))
2046                 return -EINVAL;
2047
2048         /* bt848 has a 12-bit register space */
2049         reg->reg &= 0xfff;
2050         reg->val = btread(reg->reg);
2051         reg->size = 1;
2052
2053         return 0;
2054 }
2055
2056 static int bttv_s_register(struct file *file, void *f,
2057                                         struct v4l2_dbg_register *reg)
2058 {
2059         struct bttv_fh *fh = f;
2060         struct bttv *btv = fh->btv;
2061
2062         if (!capable(CAP_SYS_ADMIN))
2063                 return -EPERM;
2064
2065         if (!v4l2_chip_match_host(&reg->match))
2066                 return -EINVAL;
2067
2068         /* bt848 has a 12-bit register space */
2069         reg->reg &= 0xfff;
2070         btwrite(reg->val, reg->reg);
2071
2072         return 0;
2073 }
2074 #endif
2075
2076 /* Given cropping boundaries b and the scaled width and height of a
2077    single field or frame, which must not exceed hardware limits, this
2078    function adjusts the cropping parameters c. */
2079 static void
2080 bttv_crop_adjust        (struct bttv_crop *             c,
2081                          const struct v4l2_rect *       b,
2082                          __s32                          width,
2083                          __s32                          height,
2084                          enum v4l2_field                field)
2085 {
2086         __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
2087         __s32 max_left;
2088         __s32 max_top;
2089
2090         if (width < c->min_scaled_width) {
2091                 /* Max. hor. scale factor 16:1. */
2092                 c->rect.width = width * 16;
2093         } else if (width > c->max_scaled_width) {
2094                 /* Min. hor. scale factor 1:1. */
2095                 c->rect.width = width;
2096
2097                 max_left = b->left + b->width - width;
2098                 max_left = min(max_left, (__s32) MAX_HDELAY);
2099                 if (c->rect.left > max_left)
2100                         c->rect.left = max_left;
2101         }
2102
2103         if (height < c->min_scaled_height) {
2104                 /* Max. vert. scale factor 16:1, single fields 8:1. */
2105                 c->rect.height = height * 16;
2106         } else if (frame_height > c->max_scaled_height) {
2107                 /* Min. vert. scale factor 1:1.
2108                    Top and height count field lines times two. */
2109                 c->rect.height = (frame_height + 1) & ~1;
2110
2111                 max_top = b->top + b->height - c->rect.height;
2112                 if (c->rect.top > max_top)
2113                         c->rect.top = max_top;
2114         }
2115
2116         bttv_crop_calc_limits(c);
2117 }
2118
2119 /* Returns an error if scaling to a frame or single field with the given
2120    width and height is not possible with the current cropping parameters
2121    and width aligned according to width_mask. If adjust_size is TRUE the
2122    function may adjust the width and/or height instead, rounding width
2123    to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
2124    also adjust the current cropping parameters to get closer to the
2125    desired image size. */
2126 static int
2127 limit_scaled_size       (struct bttv_fh *               fh,
2128                          __s32 *                        width,
2129                          __s32 *                        height,
2130                          enum v4l2_field                field,
2131                          unsigned int                   width_mask,
2132                          unsigned int                   width_bias,
2133                          int                            adjust_size,
2134                          int                            adjust_crop)
2135 {
2136         struct bttv *btv = fh->btv;
2137         const struct v4l2_rect *b;
2138         struct bttv_crop *c;
2139         __s32 min_width;
2140         __s32 min_height;
2141         __s32 max_width;
2142         __s32 max_height;
2143         int rc;
2144
2145         BUG_ON((int) width_mask >= 0 ||
2146                width_bias >= (unsigned int) -width_mask);
2147
2148         /* Make sure tvnorm, vbi_end and the current cropping parameters
2149            remain consistent until we're done. */
2150         mutex_lock(&btv->lock);
2151
2152         b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2153
2154         /* Do crop - use current, don't - use default parameters. */
2155         c = &btv->crop[!!fh->do_crop];
2156
2157         if (fh->do_crop
2158             && adjust_size
2159             && adjust_crop
2160             && !locked_btres(btv, VIDEO_RESOURCES)) {
2161                 min_width = 48;
2162                 min_height = 32;
2163
2164                 /* We cannot scale up. When the scaled image is larger
2165                    than crop.rect we adjust the crop.rect as required
2166                    by the V4L2 spec, hence cropcap.bounds are our limit. */
2167                 max_width = min(b->width, (__s32) MAX_HACTIVE);
2168                 max_height = b->height;
2169
2170                 /* We cannot capture the same line as video and VBI data.
2171                    Note btv->vbi_end is really a minimum, see
2172                    bttv_vbi_try_fmt(). */
2173                 if (btv->vbi_end > b->top) {
2174                         max_height -= btv->vbi_end - b->top;
2175                         rc = -EBUSY;
2176                         if (min_height > max_height)
2177                                 goto fail;
2178                 }
2179         } else {
2180                 rc = -EBUSY;
2181                 if (btv->vbi_end > c->rect.top)
2182                         goto fail;
2183
2184                 min_width  = c->min_scaled_width;
2185                 min_height = c->min_scaled_height;
2186                 max_width  = c->max_scaled_width;
2187                 max_height = c->max_scaled_height;
2188
2189                 adjust_crop = 0;
2190         }
2191
2192         min_width = (min_width - width_mask - 1) & width_mask;
2193         max_width = max_width & width_mask;
2194
2195         /* Max. scale factor is 16:1 for frames, 8:1 for fields. */
2196         min_height = min_height;
2197         /* Min. scale factor is 1:1. */
2198         max_height >>= !V4L2_FIELD_HAS_BOTH(field);
2199
2200         if (adjust_size) {
2201                 *width = clamp(*width, min_width, max_width);
2202                 *height = clamp(*height, min_height, max_height);
2203
2204                 /* Round after clamping to avoid overflow. */
2205                 *width = (*width + width_bias) & width_mask;
2206
2207                 if (adjust_crop) {
2208                         bttv_crop_adjust(c, b, *width, *height, field);
2209
2210                         if (btv->vbi_end > c->rect.top) {
2211                                 /* Move the crop window out of the way. */
2212                                 c->rect.top = btv->vbi_end;
2213                         }
2214                 }
2215         } else {
2216                 rc = -EINVAL;
2217                 if (*width  < min_width ||
2218                     *height < min_height ||
2219                     *width  > max_width ||
2220                     *height > max_height ||
2221                     0 != (*width & ~width_mask))
2222                         goto fail;
2223         }
2224
2225         rc = 0; /* success */
2226
2227  fail:
2228         mutex_unlock(&btv->lock);
2229
2230         return rc;
2231 }
2232
2233 /* Returns an error if the given overlay window dimensions are not
2234    possible with the current cropping parameters. If adjust_size is
2235    TRUE the function may adjust the window width and/or height
2236    instead, however it always rounds the horizontal position and
2237    width as btcx_align() does. If adjust_crop is TRUE the function
2238    may also adjust the current cropping parameters to get closer
2239    to the desired window size. */
2240 static int
2241 verify_window           (struct bttv_fh *               fh,
2242                          struct v4l2_window *           win,
2243                          int                            adjust_size,
2244                          int                            adjust_crop)
2245 {
2246         enum v4l2_field field;
2247         unsigned int width_mask;
2248         int rc;
2249
2250         if (win->w.width  < 48 || win->w.height < 32)
2251                 return -EINVAL;
2252         if (win->clipcount > 2048)
2253                 return -EINVAL;
2254
2255         field = win->field;
2256
2257         if (V4L2_FIELD_ANY == field) {
2258                 __s32 height2;
2259
2260                 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2261                 field = (win->w.height > height2)
2262                         ? V4L2_FIELD_INTERLACED
2263                         : V4L2_FIELD_TOP;
2264         }
2265         switch (field) {
2266         case V4L2_FIELD_TOP:
2267         case V4L2_FIELD_BOTTOM:
2268         case V4L2_FIELD_INTERLACED:
2269                 break;
2270         default:
2271                 return -EINVAL;
2272         }
2273
2274         /* 4-byte alignment. */
2275         if (NULL == fh->ovfmt)
2276                 return -EINVAL;
2277         width_mask = ~0;
2278         switch (fh->ovfmt->depth) {
2279         case 8:
2280         case 24:
2281                 width_mask = ~3;
2282                 break;
2283         case 16:
2284                 width_mask = ~1;
2285                 break;
2286         case 32:
2287                 break;
2288         default:
2289                 BUG();
2290         }
2291
2292         win->w.width -= win->w.left & ~width_mask;
2293         win->w.left = (win->w.left - width_mask - 1) & width_mask;
2294
2295         rc = limit_scaled_size(fh, &win->w.width, &win->w.height,
2296                                field, width_mask,
2297                                /* width_bias: round down */ 0,
2298                                adjust_size, adjust_crop);
2299         if (0 != rc)
2300                 return rc;
2301
2302         win->field = field;
2303         return 0;
2304 }
2305
2306 static int setup_window(struct bttv_fh *fh, struct bttv *btv,
2307                         struct v4l2_window *win, int fixup)
2308 {
2309         struct v4l2_clip *clips = NULL;
2310         int n,size,retval = 0;
2311
2312         if (NULL == fh->ovfmt)
2313                 return -EINVAL;
2314         if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2315                 return -EINVAL;
2316         retval = verify_window(fh, win,
2317                                /* adjust_size */ fixup,
2318                                /* adjust_crop */ fixup);
2319         if (0 != retval)
2320                 return retval;
2321
2322         /* copy clips  --  luckily v4l1 + v4l2 are binary
2323            compatible here ...*/
2324         n = win->clipcount;
2325         size = sizeof(*clips)*(n+4);
2326         clips = kmalloc(size,GFP_KERNEL);
2327         if (NULL == clips)
2328                 return -ENOMEM;
2329         if (n > 0) {
2330                 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2331                         kfree(clips);
2332                         return -EFAULT;
2333                 }
2334         }
2335         /* clip against screen */
2336         if (NULL != btv->fbuf.base)
2337                 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2338                                       &win->w, clips, n);
2339         btcx_sort_clips(clips,n);
2340
2341         /* 4-byte alignments */
2342         switch (fh->ovfmt->depth) {
2343         case 8:
2344         case 24:
2345                 btcx_align(&win->w, clips, n, 3);
2346                 break;
2347         case 16:
2348                 btcx_align(&win->w, clips, n, 1);
2349                 break;
2350         case 32:
2351                 /* no alignment fixups needed */
2352                 break;
2353         default:
2354                 BUG();
2355         }
2356
2357         mutex_lock(&fh->cap.vb_lock);
2358         kfree(fh->ov.clips);
2359         fh->ov.clips    = clips;
2360         fh->ov.nclips   = n;
2361
2362         fh->ov.w        = win->w;
2363         fh->ov.field    = win->field;
2364         fh->ov.setup_ok = 1;
2365         btv->init.ov.w.width   = win->w.width;
2366         btv->init.ov.w.height  = win->w.height;
2367         btv->init.ov.field     = win->field;
2368
2369         /* update overlay if needed */
2370         retval = 0;
2371         if (check_btres(fh, RESOURCE_OVERLAY)) {
2372                 struct bttv_buffer *new;
2373
2374                 new = videobuf_sg_alloc(sizeof(*new));
2375                 new->crop = btv->crop[!!fh->do_crop].rect;
2376                 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2377                 retval = bttv_switch_overlay(btv,fh,new);
2378         }
2379         mutex_unlock(&fh->cap.vb_lock);
2380         return retval;
2381 }
2382
2383 /* ----------------------------------------------------------------------- */
2384
2385 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2386 {
2387         struct videobuf_queue* q = NULL;
2388
2389         switch (fh->type) {
2390         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2391                 q = &fh->cap;
2392                 break;
2393         case V4L2_BUF_TYPE_VBI_CAPTURE:
2394                 q = &fh->vbi;
2395                 break;
2396         default:
2397                 BUG();
2398         }
2399         return q;
2400 }
2401
2402 static int bttv_resource(struct bttv_fh *fh)
2403 {
2404         int res = 0;
2405
2406         switch (fh->type) {
2407         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2408                 res = RESOURCE_VIDEO_STREAM;
2409                 break;
2410         case V4L2_BUF_TYPE_VBI_CAPTURE:
2411                 res = RESOURCE_VBI;
2412                 break;
2413         default:
2414                 BUG();
2415         }
2416         return res;
2417 }
2418
2419 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2420 {
2421         struct videobuf_queue *q = bttv_queue(fh);
2422         int res = bttv_resource(fh);
2423
2424         if (check_btres(fh,res))
2425                 return -EBUSY;
2426         if (videobuf_queue_is_busy(q))
2427                 return -EBUSY;
2428         fh->type = type;
2429         return 0;
2430 }
2431
2432 static void
2433 pix_format_set_size     (struct v4l2_pix_format *       f,
2434                          const struct bttv_format *     fmt,
2435                          unsigned int                   width,
2436                          unsigned int                   height)
2437 {
2438         f->width = width;
2439         f->height = height;
2440
2441         if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2442                 f->bytesperline = width; /* Y plane */
2443                 f->sizeimage = (width * height * fmt->depth) >> 3;
2444         } else {
2445                 f->bytesperline = (width * fmt->depth) >> 3;
2446                 f->sizeimage = height * f->bytesperline;
2447         }
2448 }
2449
2450 static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
2451                                         struct v4l2_format *f)
2452 {
2453         struct bttv_fh *fh  = priv;
2454
2455         pix_format_set_size(&f->fmt.pix, fh->fmt,
2456                                 fh->width, fh->height);
2457         f->fmt.pix.field        = fh->cap.field;
2458         f->fmt.pix.pixelformat  = fh->fmt->fourcc;
2459
2460         return 0;
2461 }
2462
2463 static int bttv_g_fmt_vid_overlay(struct file *file, void *priv,
2464                                         struct v4l2_format *f)
2465 {
2466         struct bttv_fh *fh  = priv;
2467
2468         f->fmt.win.w     = fh->ov.w;
2469         f->fmt.win.field = fh->ov.field;
2470
2471         return 0;
2472 }
2473
2474 static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
2475                                                 struct v4l2_format *f)
2476 {
2477         const struct bttv_format *fmt;
2478         struct bttv_fh *fh = priv;
2479         struct bttv *btv = fh->btv;
2480         enum v4l2_field field;
2481         __s32 width, height;
2482         int rc;
2483
2484         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2485         if (NULL == fmt)
2486                 return -EINVAL;
2487
2488         field = f->fmt.pix.field;
2489
2490         if (V4L2_FIELD_ANY == field) {
2491                 __s32 height2;
2492
2493                 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2494                 field = (f->fmt.pix.height > height2)
2495                         ? V4L2_FIELD_INTERLACED
2496                         : V4L2_FIELD_BOTTOM;
2497         }
2498
2499         if (V4L2_FIELD_SEQ_BT == field)
2500                 field = V4L2_FIELD_SEQ_TB;
2501
2502         switch (field) {
2503         case V4L2_FIELD_TOP:
2504         case V4L2_FIELD_BOTTOM:
2505         case V4L2_FIELD_ALTERNATE:
2506         case V4L2_FIELD_INTERLACED:
2507                 break;
2508         case V4L2_FIELD_SEQ_TB:
2509                 if (fmt->flags & FORMAT_FLAGS_PLANAR)
2510                         return -EINVAL;
2511                 break;
2512         default:
2513                 return -EINVAL;
2514         }
2515
2516         width = f->fmt.pix.width;
2517         height = f->fmt.pix.height;
2518
2519         rc = limit_scaled_size(fh, &width, &height, field,
2520                                /* width_mask: 4 pixels */ ~3,
2521                                /* width_bias: nearest */ 2,
2522                                /* adjust_size */ 1,
2523                                /* adjust_crop */ 0);
2524         if (0 != rc)
2525                 return rc;
2526
2527         /* update data for the application */
2528         f->fmt.pix.field = field;
2529         pix_format_set_size(&f->fmt.pix, fmt, width, height);
2530
2531         return 0;
2532 }
2533
2534 static int bttv_try_fmt_vid_overlay(struct file *file, void *priv,
2535                                                 struct v4l2_format *f)
2536 {
2537         struct bttv_fh *fh = priv;
2538
2539         return verify_window(fh, &f->fmt.win,
2540                         /* adjust_size */ 1,
2541                         /* adjust_crop */ 0);
2542 }
2543
2544 static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2545                                 struct v4l2_format *f)
2546 {
2547         int retval;
2548         const struct bttv_format *fmt;
2549         struct bttv_fh *fh = priv;
2550         struct bttv *btv = fh->btv;
2551         __s32 width, height;
2552         enum v4l2_field field;
2553
2554         retval = bttv_switch_type(fh, f->type);
2555         if (0 != retval)
2556                 return retval;
2557
2558         retval = bttv_try_fmt_vid_cap(file, priv, f);
2559         if (0 != retval)
2560                 return retval;
2561
2562         width = f->fmt.pix.width;
2563         height = f->fmt.pix.height;
2564         field = f->fmt.pix.field;
2565
2566         retval = limit_scaled_size(fh, &width, &height, f->fmt.pix.field,
2567                                /* width_mask: 4 pixels */ ~3,
2568                                /* width_bias: nearest */ 2,
2569                                /* adjust_size */ 1,
2570                                /* adjust_crop */ 1);
2571         if (0 != retval)
2572                 return retval;
2573
2574         f->fmt.pix.field = field;
2575
2576         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2577
2578         /* update our state informations */
2579         mutex_lock(&fh->cap.vb_lock);
2580         fh->fmt              = fmt;
2581         fh->cap.field        = f->fmt.pix.field;
2582         fh->cap.last         = V4L2_FIELD_NONE;
2583         fh->width            = f->fmt.pix.width;
2584         fh->height           = f->fmt.pix.height;
2585         btv->init.fmt        = fmt;
2586         btv->init.width      = f->fmt.pix.width;
2587         btv->init.height     = f->fmt.pix.height;
2588         mutex_unlock(&fh->cap.vb_lock);
2589
2590         return 0;
2591 }
2592
2593 static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
2594                                 struct v4l2_format *f)
2595 {
2596         struct bttv_fh *fh = priv;
2597         struct bttv *btv = fh->btv;
2598
2599         if (no_overlay > 0) {
2600                 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2601                 return -EINVAL;
2602         }
2603
2604         return setup_window(fh, btv, &f->fmt.win, 1);
2605 }
2606
2607 #ifdef CONFIG_VIDEO_V4L1_COMPAT
2608 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
2609 {
2610         int retval;
2611         unsigned int i;
2612         struct bttv_fh *fh = priv;
2613
2614         mutex_lock(&fh->cap.vb_lock);
2615         retval = __videobuf_mmap_setup(&fh->cap, gbuffers, gbufsize,
2616                                      V4L2_MEMORY_MMAP);
2617         if (retval < 0) {
2618                 mutex_unlock(&fh->cap.vb_lock);
2619                 return retval;
2620         }
2621
2622         gbuffers = retval;
2623         memset(mbuf, 0, sizeof(*mbuf));
2624         mbuf->frames = gbuffers;
2625         mbuf->size   = gbuffers * gbufsize;
2626
2627         for (i = 0; i < gbuffers; i++)
2628                 mbuf->offsets[i] = i * gbufsize;
2629
2630         mutex_unlock(&fh->cap.vb_lock);
2631         return 0;
2632 }
2633 #endif
2634
2635 static int bttv_querycap(struct file *file, void  *priv,
2636                                 struct v4l2_capability *cap)
2637 {
2638         struct bttv_fh *fh = priv;
2639         struct bttv *btv = fh->btv;
2640
2641         if (0 == v4l2)
2642                 return -EINVAL;
2643
2644         strlcpy(cap->driver, "bttv", sizeof(cap->driver));
2645         strlcpy(cap->card, btv->video_dev->name, sizeof(cap->card));
2646         snprintf(cap->bus_info, sizeof(cap->bus_info),
2647                  "PCI:%s", pci_name(btv->c.pci));
2648         cap->version = BTTV_VERSION_CODE;
2649         cap->capabilities =
2650                 V4L2_CAP_VIDEO_CAPTURE |
2651                 V4L2_CAP_VBI_CAPTURE |
2652                 V4L2_CAP_READWRITE |
2653                 V4L2_CAP_STREAMING;
2654         if (btv->has_saa6588)
2655                 cap->capabilities |= V4L2_CAP_RDS_CAPTURE;
2656         if (no_overlay <= 0)
2657                 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2658
2659         if (btv->tuner_type != TUNER_ABSENT)
2660                 cap->capabilities |= V4L2_CAP_TUNER;
2661         return 0;
2662 }
2663
2664 static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f)
2665 {
2666         int index = -1, i;
2667
2668         for (i = 0; i < FORMATS; i++) {
2669                 if (formats[i].fourcc != -1)
2670                         index++;
2671                 if ((unsigned int)index == f->index)
2672                         break;
2673         }
2674         if (FORMATS == i)
2675                 return -EINVAL;
2676
2677         f->pixelformat = formats[i].fourcc;
2678         strlcpy(f->description, formats[i].name, sizeof(f->description));
2679
2680         return i;
2681 }
2682
2683 static int bttv_enum_fmt_vid_cap(struct file *file, void  *priv,
2684                                 struct v4l2_fmtdesc *f)
2685 {
2686         int rc = bttv_enum_fmt_cap_ovr(f);
2687
2688         if (rc < 0)
2689                 return rc;
2690
2691         return 0;
2692 }
2693
2694 static int bttv_enum_fmt_vid_overlay(struct file *file, void  *priv,
2695                                         struct v4l2_fmtdesc *f)
2696 {
2697         int rc;
2698
2699         if (no_overlay > 0) {
2700                 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2701                 return -EINVAL;
2702         }
2703
2704         rc = bttv_enum_fmt_cap_ovr(f);
2705
2706         if (rc < 0)
2707                 return rc;
2708
2709         if (!(formats[rc].flags & FORMAT_FLAGS_PACKED))
2710                 return -EINVAL;
2711
2712         return 0;
2713 }
2714
2715 static int bttv_g_fbuf(struct file *file, void *f,
2716                                 struct v4l2_framebuffer *fb)
2717 {
2718         struct bttv_fh *fh = f;
2719         struct bttv *btv = fh->btv;
2720
2721         *fb = btv->fbuf;
2722         fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2723         if (fh->ovfmt)
2724                 fb->fmt.pixelformat  = fh->ovfmt->fourcc;
2725         return 0;
2726 }
2727
2728 static int bttv_overlay(struct file *file, void *f, unsigned int on)
2729 {
2730         struct bttv_fh *fh = f;
2731         struct bttv *btv = fh->btv;
2732         struct bttv_buffer *new;
2733         int retval;
2734
2735         if (on) {
2736                 /* verify args */
2737                 if (NULL == btv->fbuf.base)
2738                         return -EINVAL;
2739                 if (!fh->ov.setup_ok) {
2740                         dprintk("bttv%d: overlay: !setup_ok\n", btv->c.nr);
2741                         return -EINVAL;
2742                 }
2743         }
2744
2745         if (!check_alloc_btres(btv, fh, RESOURCE_OVERLAY))
2746                 return -EBUSY;
2747
2748         mutex_lock(&fh->cap.vb_lock);
2749         if (on) {
2750                 fh->ov.tvnorm = btv->tvnorm;
2751                 new = videobuf_sg_alloc(sizeof(*new));
2752                 new->crop = btv->crop[!!fh->do_crop].rect;
2753                 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2754         } else {
2755                 new = NULL;
2756         }
2757
2758         /* switch over */
2759         retval = bttv_switch_overlay(btv, fh, new);
2760         mutex_unlock(&fh->cap.vb_lock);
2761         return retval;
2762 }
2763
2764 static int bttv_s_fbuf(struct file *file, void *f,
2765                                 struct v4l2_framebuffer *fb)
2766 {
2767         struct bttv_fh *fh = f;
2768         struct bttv *btv = fh->btv;
2769         const struct bttv_format *fmt;
2770         int retval;
2771
2772         if (!capable(CAP_SYS_ADMIN) &&
2773                 !capable(CAP_SYS_RAWIO))
2774                 return -EPERM;
2775
2776         /* check args */
2777         fmt = format_by_fourcc(fb->fmt.pixelformat);
2778         if (NULL == fmt)
2779                 return -EINVAL;
2780         if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2781                 return -EINVAL;
2782
2783         retval = -EINVAL;
2784         if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2785                 __s32 width = fb->fmt.width;
2786                 __s32 height = fb->fmt.height;
2787
2788                 retval = limit_scaled_size(fh, &width, &height,
2789                                            V4L2_FIELD_INTERLACED,
2790                                            /* width_mask */ ~3,
2791                                            /* width_bias */ 2,
2792                                            /* adjust_size */ 0,
2793                                            /* adjust_crop */ 0);
2794                 if (0 != retval)
2795                         return retval;
2796         }
2797
2798         /* ok, accept it */
2799         mutex_lock(&fh->cap.vb_lock);
2800         btv->fbuf.base       = fb->base;
2801         btv->fbuf.fmt.width  = fb->fmt.width;
2802         btv->fbuf.fmt.height = fb->fmt.height;
2803         if (0 != fb->fmt.bytesperline)
2804                 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2805         else
2806                 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2807
2808         retval = 0;
2809         fh->ovfmt = fmt;
2810         btv->init.ovfmt = fmt;
2811         if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2812                 fh->ov.w.left   = 0;
2813                 fh->ov.w.top    = 0;
2814                 fh->ov.w.width  = fb->fmt.width;
2815                 fh->ov.w.height = fb->fmt.height;
2816                 btv->init.ov.w.width  = fb->fmt.width;
2817                 btv->init.ov.w.height = fb->fmt.height;
2818                         kfree(fh->ov.clips);
2819                 fh->ov.clips = NULL;
2820                 fh->ov.nclips = 0;
2821
2822                 if (check_btres(fh, RESOURCE_OVERLAY)) {
2823                         struct bttv_buffer *new;
2824
2825                         new = videobuf_sg_alloc(sizeof(*new));
2826                         new->crop = btv->crop[!!fh->do_crop].rect;
2827                         bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2828                         retval = bttv_switch_overlay(btv, fh, new);
2829                 }
2830         }
2831         mutex_unlock(&fh->cap.vb_lock);
2832         return retval;
2833 }
2834
2835 static int bttv_reqbufs(struct file *file, void *priv,
2836                                 struct v4l2_requestbuffers *p)
2837 {
2838         struct bttv_fh *fh = priv;
2839         return videobuf_reqbufs(bttv_queue(fh), p);
2840 }
2841
2842 static int bttv_querybuf(struct file *file, void *priv,
2843                                 struct v4l2_buffer *b)
2844 {
2845         struct bttv_fh *fh = priv;
2846         return videobuf_querybuf(bttv_queue(fh), b);
2847 }
2848
2849 static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2850 {
2851         struct bttv_fh *fh = priv;
2852         struct bttv *btv = fh->btv;
2853         int res = bttv_resource(fh);
2854
2855         if (!check_alloc_btres(btv, fh, res))
2856                 return -EBUSY;
2857
2858         return videobuf_qbuf(bttv_queue(fh), b);
2859 }
2860
2861 static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2862 {
2863         struct bttv_fh *fh = priv;
2864         return videobuf_dqbuf(bttv_queue(fh), b,
2865                         file->f_flags & O_NONBLOCK);
2866 }
2867
2868 static int bttv_streamon(struct file *file, void *priv,
2869                                         enum v4l2_buf_type type)
2870 {
2871         struct bttv_fh *fh = priv;
2872         struct bttv *btv = fh->btv;
2873         int res = bttv_resource(fh);
2874
2875         if (!check_alloc_btres(btv, fh, res))
2876                 return -EBUSY;
2877         return videobuf_streamon(bttv_queue(fh));
2878 }
2879
2880
2881 static int bttv_streamoff(struct file *file, void *priv,
2882                                         enum v4l2_buf_type type)
2883 {
2884         struct bttv_fh *fh = priv;
2885         struct bttv *btv = fh->btv;
2886         int retval;
2887         int res = bttv_resource(fh);
2888
2889
2890         retval = videobuf_streamoff(bttv_queue(fh));
2891         if (retval < 0)
2892                 return retval;
2893         free_btres(btv, fh, res);
2894         return 0;
2895 }
2896
2897 static int bttv_queryctrl(struct file *file, void *priv,
2898                                         struct v4l2_queryctrl *c)
2899 {
2900         struct bttv_fh *fh = priv;
2901         struct bttv *btv = fh->btv;
2902         const struct v4l2_queryctrl *ctrl;
2903
2904         if ((c->id <  V4L2_CID_BASE ||
2905              c->id >= V4L2_CID_LASTP1) &&
2906             (c->id <  V4L2_CID_PRIVATE_BASE ||
2907              c->id >= V4L2_CID_PRIVATE_LASTP1))
2908                 return -EINVAL;
2909
2910         if (!btv->volume_gpio && (c->id == V4L2_CID_AUDIO_VOLUME))
2911                 *c = no_ctl;
2912         else {
2913                 ctrl = ctrl_by_id(c->id);
2914
2915                 *c = (NULL != ctrl) ? *ctrl : no_ctl;
2916         }
2917
2918         return 0;
2919 }
2920
2921 static int bttv_g_parm(struct file *file, void *f,
2922                                 struct v4l2_streamparm *parm)
2923 {
2924         struct bttv_fh *fh = f;
2925         struct bttv *btv = fh->btv;
2926
2927         v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id,
2928                                     &parm->parm.capture.timeperframe);
2929         return 0;
2930 }
2931
2932 static int bttv_g_tuner(struct file *file, void *priv,
2933                                 struct v4l2_tuner *t)
2934 {
2935         struct bttv_fh *fh = priv;
2936         struct bttv *btv = fh->btv;
2937
2938         if (btv->tuner_type == TUNER_ABSENT)
2939                 return -EINVAL;
2940         if (0 != t->index)
2941                 return -EINVAL;
2942
2943         mutex_lock(&btv->lock);
2944         t->rxsubchans = V4L2_TUNER_SUB_MONO;
2945         bttv_call_all(btv, tuner, g_tuner, t);
2946         strcpy(t->name, "Television");
2947         t->capability = V4L2_TUNER_CAP_NORM;
2948         t->type       = V4L2_TUNER_ANALOG_TV;
2949         if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2950                 t->signal = 0xffff;
2951
2952         if (btv->audio_mode_gpio)
2953                 btv->audio_mode_gpio(btv, t, 0);
2954
2955         mutex_unlock(&btv->lock);
2956         return 0;
2957 }
2958
2959 static int bttv_g_priority(struct file *file, void *f, enum v4l2_priority *p)
2960 {
2961         struct bttv_fh *fh = f;
2962         struct bttv *btv = fh->btv;
2963
2964         *p = v4l2_prio_max(&btv->prio);
2965
2966         return 0;
2967 }
2968
2969 static int bttv_s_priority(struct file *file, void *f,
2970                                         enum v4l2_priority prio)
2971 {
2972         struct bttv_fh *fh = f;
2973         struct bttv *btv = fh->btv;
2974
2975         return v4l2_prio_change(&btv->prio, &fh->prio, prio);
2976 }
2977
2978 static int bttv_cropcap(struct file *file, void *priv,
2979                                 struct v4l2_cropcap *cap)
2980 {
2981         struct bttv_fh *fh = priv;
2982         struct bttv *btv = fh->btv;
2983
2984         if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2985             cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2986                 return -EINVAL;
2987
2988         *cap = bttv_tvnorms[btv->tvnorm].cropcap;
2989
2990         return 0;
2991 }
2992
2993 static int bttv_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
2994 {
2995         struct bttv_fh *fh = f;
2996         struct bttv *btv = fh->btv;
2997
2998         if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2999             crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3000                 return -EINVAL;
3001
3002         /* No fh->do_crop = 1; because btv->crop[1] may be
3003            inconsistent with fh->width or fh->height and apps
3004            do not expect a change here. */
3005
3006         crop->c = btv->crop[!!fh->do_crop].rect;
3007
3008         return 0;
3009 }
3010
3011 static int bttv_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
3012 {
3013         struct bttv_fh *fh = f;
3014         struct bttv *btv = fh->btv;
3015         const struct v4l2_rect *b;
3016         int retval;
3017         struct bttv_crop c;
3018         __s32 b_left;
3019         __s32 b_top;
3020         __s32 b_right;
3021         __s32 b_bottom;
3022
3023         if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3024             crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3025                 return -EINVAL;
3026
3027         retval = v4l2_prio_check(&btv->prio, fh->prio);
3028         if (0 != retval)
3029                 return retval;
3030
3031         /* Make sure tvnorm, vbi_end and the current cropping
3032            parameters remain consistent until we're done. Note
3033            read() may change vbi_end in check_alloc_btres(). */
3034         mutex_lock(&btv->lock);
3035
3036         retval = -EBUSY;
3037
3038         if (locked_btres(fh->btv, VIDEO_RESOURCES)) {
3039                 mutex_unlock(&btv->lock);
3040                 return retval;
3041         }
3042
3043         b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
3044
3045         b_left = b->left;
3046         b_right = b_left + b->width;
3047         b_bottom = b->top + b->height;
3048
3049         b_top = max(b->top, btv->vbi_end);
3050         if (b_top + 32 >= b_bottom) {
3051                 mutex_unlock(&btv->lock);
3052                 return retval;
3053         }
3054
3055         /* Min. scaled size 48 x 32. */
3056         c.rect.left = clamp(crop->c.left, b_left, b_right - 48);
3057         c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
3058
3059         c.rect.width = clamp(crop->c.width,
3060                              48, b_right - c.rect.left);
3061
3062         c.rect.top = clamp(crop->c.top, b_top, b_bottom - 32);
3063         /* Top and height must be a multiple of two. */
3064         c.rect.top = (c.rect.top + 1) & ~1;
3065
3066         c.rect.height = clamp(crop->c.height,
3067                               32, b_bottom - c.rect.top);
3068         c.rect.height = (c.rect.height + 1) & ~1;
3069
3070         bttv_crop_calc_limits(&c);
3071
3072         btv->crop[1] = c;
3073
3074         mutex_unlock(&btv->lock);
3075
3076         fh->do_crop = 1;
3077
3078         mutex_lock(&fh->cap.vb_lock);
3079
3080         if (fh->width < c.min_scaled_width) {
3081                 fh->width = c.min_scaled_width;
3082                 btv->init.width = c.min_scaled_width;
3083         } else if (fh->width > c.max_scaled_width) {
3084                 fh->width = c.max_scaled_width;
3085                 btv->init.width = c.max_scaled_width;
3086         }
3087
3088         if (fh->height < c.min_scaled_height) {
3089                 fh->height = c.min_scaled_height;
3090                 btv->init.height = c.min_scaled_height;
3091         } else if (fh->height > c.max_scaled_height) {
3092                 fh->height = c.max_scaled_height;
3093                 btv->init.height = c.max_scaled_height;
3094         }
3095
3096         mutex_unlock(&fh->cap.vb_lock);
3097
3098         return 0;
3099 }
3100
3101 static int bttv_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
3102 {
3103         if (unlikely(a->index))
3104                 return -EINVAL;
3105
3106         strcpy(a->name, "audio");
3107         return 0;
3108 }
3109
3110 static int bttv_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
3111 {
3112         if (unlikely(a->index))
3113                 return -EINVAL;
3114
3115         return 0;
3116 }
3117
3118 static ssize_t bttv_read(struct file *file, char __user *data,
3119                          size_t count, loff_t *ppos)
3120 {
3121         struct bttv_fh *fh = file->private_data;
3122         int retval = 0;
3123
3124         if (fh->btv->errors)
3125                 bttv_reinit_bt848(fh->btv);
3126         dprintk("bttv%d: read count=%d type=%s\n",
3127                 fh->btv->c.nr,(int)count,v4l2_type_names[fh->type]);
3128
3129         switch (fh->type) {
3130         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3131                 if (!check_alloc_btres(fh->btv, fh, RESOURCE_VIDEO_READ)) {
3132                         /* VIDEO_READ in use by another fh,
3133                            or VIDEO_STREAM by any fh. */
3134                         return -EBUSY;
3135                 }
3136                 retval = videobuf_read_one(&fh->cap, data, count, ppos,
3137                                            file->f_flags & O_NONBLOCK);
3138                 free_btres(fh->btv, fh, RESOURCE_VIDEO_READ);
3139                 break;
3140         case V4L2_BUF_TYPE_VBI_CAPTURE:
3141                 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3142                         return -EBUSY;
3143                 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
3144                                               file->f_flags & O_NONBLOCK);
3145                 break;
3146         default:
3147                 BUG();
3148         }
3149         return retval;
3150 }
3151
3152 static unsigned int bttv_poll(struct file *file, poll_table *wait)
3153 {
3154         struct bttv_fh *fh = file->private_data;
3155         struct bttv_buffer *buf;
3156         enum v4l2_field field;
3157         unsigned int rc = POLLERR;
3158
3159         if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
3160                 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3161                         return POLLERR;
3162                 return videobuf_poll_stream(file, &fh->vbi, wait);
3163         }
3164
3165         if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
3166                 mutex_lock(&fh->cap.vb_lock);
3167                 /* streaming capture */
3168                 if (list_empty(&fh->cap.stream))
3169                         goto err;
3170                 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
3171         } else {
3172                 /* read() capture */
3173                 mutex_lock(&fh->cap.vb_lock);
3174                 if (NULL == fh->cap.read_buf) {
3175                         /* need to capture a new frame */
3176                         if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
3177                                 goto err;
3178                         fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize);
3179                         if (NULL == fh->cap.read_buf)
3180                                 goto err;
3181                         fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
3182                         field = videobuf_next_field(&fh->cap);
3183                         if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
3184                                 kfree (fh->cap.read_buf);
3185                                 fh->cap.read_buf = NULL;
3186                                 goto err;
3187                         }
3188                         fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
3189                         fh->cap.read_off = 0;
3190                 }
3191                 mutex_unlock(&fh->cap.vb_lock);
3192                 buf = (struct bttv_buffer*)fh->cap.read_buf;
3193         }
3194
3195         poll_wait(file, &buf->vb.done, wait);
3196         if (buf->vb.state == VIDEOBUF_DONE ||
3197             buf->vb.state == VIDEOBUF_ERROR)
3198                 rc =  POLLIN|POLLRDNORM;
3199         else
3200                 rc = 0;
3201 err:
3202         mutex_unlock(&fh->cap.vb_lock);
3203         return rc;
3204 }
3205
3206 static int bttv_open(struct file *file)
3207 {
3208         struct video_device *vdev = video_devdata(file);
3209         struct bttv *btv = video_drvdata(file);
3210         struct bttv_fh *fh;
3211         enum v4l2_buf_type type = 0;
3212
3213         dprintk(KERN_DEBUG "bttv: open dev=%s\n", video_device_node_name(vdev));
3214
3215         if (vdev->vfl_type == VFL_TYPE_GRABBER) {
3216                 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3217         } else if (vdev->vfl_type == VFL_TYPE_VBI) {
3218                 type = V4L2_BUF_TYPE_VBI_CAPTURE;
3219         } else {
3220                 WARN_ON(1);
3221                 return -ENODEV;
3222         }
3223
3224         lock_kernel();
3225
3226         dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
3227                 btv->c.nr,v4l2_type_names[type]);
3228
3229         /* allocate per filehandle data */
3230         fh = kmalloc(sizeof(*fh),GFP_KERNEL);
3231         if (NULL == fh) {
3232                 unlock_kernel();
3233                 return -ENOMEM;
3234         }
3235         file->private_data = fh;
3236         *fh = btv->init;
3237         fh->type = type;
3238         fh->ov.setup_ok = 0;
3239         v4l2_prio_open(&btv->prio, &fh->prio);
3240
3241         videobuf_queue_sg_init(&fh->cap, &bttv_video_qops,
3242                             &btv->c.pci->dev, &btv->s_lock,
3243                             V4L2_BUF_TYPE_VIDEO_CAPTURE,
3244                             V4L2_FIELD_INTERLACED,
3245                             sizeof(struct bttv_buffer),
3246                             fh);
3247         videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops,
3248                             &btv->c.pci->dev, &btv->s_lock,
3249                             V4L2_BUF_TYPE_VBI_CAPTURE,
3250                             V4L2_FIELD_SEQ_TB,
3251                             sizeof(struct bttv_buffer),
3252                             fh);
3253         set_tvnorm(btv,btv->tvnorm);
3254         set_input(btv, btv->input, btv->tvnorm);
3255
3256         btv->users++;
3257
3258         /* The V4L2 spec requires one global set of cropping parameters
3259            which only change on request. These are stored in btv->crop[1].
3260            However for compatibility with V4L apps and cropping unaware
3261            V4L2 apps we now reset the cropping parameters as seen through
3262            this fh, which is to say VIDIOC_G_CROP and scaling limit checks
3263            will use btv->crop[0], the default cropping parameters for the
3264            current video standard, and VIDIOC_S_FMT will not implicitely
3265            change the cropping parameters until VIDIOC_S_CROP has been
3266            called. */
3267         fh->do_crop = !reset_crop; /* module parameter */
3268
3269         /* Likewise there should be one global set of VBI capture
3270            parameters, but for compatibility with V4L apps and earlier
3271            driver versions each fh has its own parameters. */
3272         bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3273
3274         bttv_field_count(btv);
3275         unlock_kernel();
3276         return 0;
3277 }
3278
3279 static int bttv_release(struct file *file)
3280 {
3281         struct bttv_fh *fh = file->private_data;
3282         struct bttv *btv = fh->btv;
3283
3284         /* turn off overlay */
3285         if (check_btres(fh, RESOURCE_OVERLAY))
3286                 bttv_switch_overlay(btv,fh,NULL);
3287
3288         /* stop video capture */
3289         if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
3290                 videobuf_streamoff(&fh->cap);
3291                 free_btres(btv,fh,RESOURCE_VIDEO_STREAM);
3292         }
3293         if (fh->cap.read_buf) {
3294                 buffer_release(&fh->cap,fh->cap.read_buf);
3295                 kfree(fh->cap.read_buf);
3296         }
3297         if (check_btres(fh, RESOURCE_VIDEO_READ)) {
3298                 free_btres(btv, fh, RESOURCE_VIDEO_READ);
3299         }
3300
3301         /* stop vbi capture */
3302         if (check_btres(fh, RESOURCE_VBI)) {
3303                 videobuf_stop(&fh->vbi);
3304                 free_btres(btv,fh,RESOURCE_VBI);
3305         }
3306
3307         /* free stuff */
3308         videobuf_mmap_free(&fh->cap);
3309         videobuf_mmap_free(&fh->vbi);
3310         v4l2_prio_close(&btv->prio, fh->prio);
3311         file->private_data = NULL;
3312         kfree(fh);
3313
3314         btv->users--;
3315         bttv_field_count(btv);
3316
3317         if (!btv->users)
3318                 audio_mute(btv, 1);
3319
3320         return 0;
3321 }
3322
3323 static int
3324 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3325 {
3326         struct bttv_fh *fh = file->private_data;
3327
3328         dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3329                 fh->btv->c.nr, v4l2_type_names[fh->type],
3330                 vma->vm_start, vma->vm_end - vma->vm_start);
3331         return videobuf_mmap_mapper(bttv_queue(fh),vma);
3332 }
3333
3334 static const struct v4l2_file_operations bttv_fops =
3335 {
3336         .owner    = THIS_MODULE,
3337         .open     = bttv_open,
3338         .release  = bttv_release,
3339         .ioctl    = video_ioctl2,
3340         .read     = bttv_read,
3341         .mmap     = bttv_mmap,
3342         .poll     = bttv_poll,
3343 };
3344
3345 static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
3346         .vidioc_querycap                = bttv_querycap,
3347         .vidioc_enum_fmt_vid_cap        = bttv_enum_fmt_vid_cap,
3348         .vidioc_g_fmt_vid_cap           = bttv_g_fmt_vid_cap,
3349         .vidioc_try_fmt_vid_cap         = bttv_try_fmt_vid_cap,
3350         .vidioc_s_fmt_vid_cap           = bttv_s_fmt_vid_cap,
3351         .vidioc_enum_fmt_vid_overlay    = bttv_enum_fmt_vid_overlay,
3352         .vidioc_g_fmt_vid_overlay       = bttv_g_fmt_vid_overlay,
3353         .vidioc_try_fmt_vid_overlay     = bttv_try_fmt_vid_overlay,
3354         .vidioc_s_fmt_vid_overlay       = bttv_s_fmt_vid_overlay,
3355         .vidioc_g_fmt_vbi_cap           = bttv_g_fmt_vbi_cap,
3356         .vidioc_try_fmt_vbi_cap         = bttv_try_fmt_vbi_cap,
3357         .vidioc_s_fmt_vbi_cap           = bttv_s_fmt_vbi_cap,
3358         .vidioc_g_audio                 = bttv_g_audio,
3359         .vidioc_s_audio                 = bttv_s_audio,
3360         .vidioc_cropcap                 = bttv_cropcap,
3361         .vidioc_reqbufs                 = bttv_reqbufs,
3362         .vidioc_querybuf                = bttv_querybuf,
3363         .vidioc_qbuf                    = bttv_qbuf,
3364         .vidioc_dqbuf                   = bttv_dqbuf,
3365         .vidioc_s_std                   = bttv_s_std,
3366         .vidioc_enum_input              = bttv_enum_input,
3367         .vidioc_g_input                 = bttv_g_input,
3368         .vidioc_s_input                 = bttv_s_input,
3369         .vidioc_queryctrl               = bttv_queryctrl,
3370         .vidioc_g_ctrl                  = bttv_g_ctrl,
3371         .vidioc_s_ctrl                  = bttv_s_ctrl,
3372         .vidioc_streamon                = bttv_streamon,
3373         .vidioc_streamoff               = bttv_streamoff,
3374         .vidioc_g_tuner                 = bttv_g_tuner,
3375         .vidioc_s_tuner                 = bttv_s_tuner,
3376 #ifdef CONFIG_VIDEO_V4L1_COMPAT
3377         .vidiocgmbuf                    = vidiocgmbuf,
3378 #endif
3379         .vidioc_g_crop                  = bttv_g_crop,
3380         .vidioc_s_crop                  = bttv_s_crop,
3381         .vidioc_g_fbuf                  = bttv_g_fbuf,
3382         .vidioc_s_fbuf                  = bttv_s_fbuf,
3383         .vidioc_overlay                 = bttv_overlay,
3384         .vidioc_g_priority              = bttv_g_priority,
3385         .vidioc_s_priority              = bttv_s_priority,
3386         .vidioc_g_parm                  = bttv_g_parm,
3387         .vidioc_g_frequency             = bttv_g_frequency,
3388         .vidioc_s_frequency             = bttv_s_frequency,
3389         .vidioc_log_status              = bttv_log_status,
3390         .vidioc_querystd                = bttv_querystd,
3391 #ifdef CONFIG_VIDEO_ADV_DEBUG
3392         .vidioc_g_register              = bttv_g_register,
3393         .vidioc_s_register              = bttv_s_register,
3394 #endif
3395 };
3396
3397 static struct video_device bttv_video_template = {
3398         .fops         = &bttv_fops,
3399         .ioctl_ops    = &bttv_ioctl_ops,
3400         .tvnorms      = BTTV_NORMS,
3401         .current_norm = V4L2_STD_PAL,
3402 };
3403
3404 /* ----------------------------------------------------------------------- */
3405 /* radio interface                                                         */
3406
3407 static int radio_open(struct file *file)
3408 {
3409         struct video_device *vdev = video_devdata(file);
3410         struct bttv *btv = video_drvdata(file);
3411         struct bttv_fh *fh;
3412
3413         dprintk("bttv: open dev=%s\n", video_device_node_name(vdev));
3414
3415         lock_kernel();
3416
3417         dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3418
3419         /* allocate per filehandle data */
3420         fh = kmalloc(sizeof(*fh), GFP_KERNEL);
3421         if (NULL == fh) {
3422                 unlock_kernel();
3423                 return -ENOMEM;
3424         }
3425         file->private_data = fh;
3426         *fh = btv->init;
3427         v4l2_prio_open(&btv->prio, &fh->prio);
3428
3429         mutex_lock(&btv->lock);
3430
3431         btv->radio_user++;
3432
3433         bttv_call_all(btv, tuner, s_radio);
3434         audio_input(btv,TVAUDIO_INPUT_RADIO);
3435
3436         mutex_unlock(&btv->lock);
3437         unlock_kernel();
3438         return 0;
3439 }
3440
3441 static int radio_release(struct file *file)
3442 {
3443         struct bttv_fh *fh = file->private_data;
3444         struct bttv *btv = fh->btv;
3445         struct rds_command cmd;
3446
3447         v4l2_prio_close(&btv->prio, fh->prio);
3448         file->private_data = NULL;
3449         kfree(fh);
3450
3451         btv->radio_user--;
3452
3453         bttv_call_all(btv, core, ioctl, RDS_CMD_CLOSE, &cmd);
3454
3455         return 0;
3456 }
3457
3458 static int radio_querycap(struct file *file, void *priv,
3459                                         struct v4l2_capability *cap)
3460 {
3461         struct bttv_fh *fh = priv;
3462         struct bttv *btv = fh->btv;
3463
3464         strcpy(cap->driver, "bttv");
3465         strlcpy(cap->card, btv->radio_dev->name, sizeof(cap->card));
3466         sprintf(cap->bus_info, "PCI:%s", pci_name(btv->c.pci));
3467         cap->version = BTTV_VERSION_CODE;
3468         cap->capabilities = V4L2_CAP_TUNER;
3469
3470         return 0;
3471 }
3472
3473 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3474 {
3475         struct bttv_fh *fh = priv;
3476         struct bttv *btv = fh->btv;
3477
3478         if (btv->tuner_type == TUNER_ABSENT)
3479                 return -EINVAL;
3480         if (0 != t->index)
3481                 return -EINVAL;
3482         mutex_lock(&btv->lock);
3483         strcpy(t->name, "Radio");
3484         t->type = V4L2_TUNER_RADIO;
3485
3486         bttv_call_all(btv, tuner, g_tuner, t);
3487
3488         if (btv->audio_mode_gpio)
3489                 btv->audio_mode_gpio(btv, t, 0);
3490
3491         mutex_unlock(&btv->lock);
3492
3493         return 0;
3494 }
3495
3496 static int radio_enum_input(struct file *file, void *priv,
3497                                 struct v4l2_input *i)
3498 {
3499         if (i->index != 0)
3500                 return -EINVAL;
3501
3502         strcpy(i->name, "Radio");
3503         i->type = V4L2_INPUT_TYPE_TUNER;
3504
3505         return 0;
3506 }
3507
3508 static int radio_g_audio(struct file *file, void *priv,
3509                                         struct v4l2_audio *a)
3510 {
3511         if (unlikely(a->index))
3512                 return -EINVAL;
3513
3514         strcpy(a->name, "Radio");
3515
3516         return 0;
3517 }
3518
3519 static int radio_s_tuner(struct file *file, void *priv,
3520                                         struct v4l2_tuner *t)
3521 {
3522         struct bttv_fh *fh = priv;
3523         struct bttv *btv = fh->btv;
3524
3525         if (0 != t->index)
3526                 return -EINVAL;
3527
3528         bttv_call_all(btv, tuner, g_tuner, t);
3529         return 0;
3530 }
3531
3532 static int radio_s_audio(struct file *file, void *priv,
3533                                         struct v4l2_audio *a)
3534 {
3535         if (unlikely(a->index))
3536                 return -EINVAL;
3537
3538         return 0;
3539 }
3540
3541 static int radio_s_input(struct file *filp, void *priv, unsigned int i)
3542 {
3543         if (unlikely(i))
3544                 return -EINVAL;
3545
3546         return 0;
3547 }
3548
3549 static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
3550 {
3551         return 0;
3552 }
3553
3554 static int radio_queryctrl(struct file *file, void *priv,
3555                                         struct v4l2_queryctrl *c)
3556 {
3557         const struct v4l2_queryctrl *ctrl;
3558
3559         if (c->id <  V4L2_CID_BASE ||
3560                         c->id >= V4L2_CID_LASTP1)
3561                 return -EINVAL;
3562
3563         if (c->id == V4L2_CID_AUDIO_MUTE) {
3564                 ctrl = ctrl_by_id(c->id);
3565                 *c = *ctrl;
3566         } else
3567                 *c = no_ctl;
3568
3569         return 0;
3570 }
3571
3572 static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
3573 {
3574         *i = 0;
3575         return 0;
3576 }
3577
3578 static ssize_t radio_read(struct file *file, char __user *data,
3579                          size_t count, loff_t *ppos)
3580 {
3581         struct bttv_fh *fh = file->private_data;
3582         struct bttv *btv = fh->btv;
3583         struct rds_command cmd;
3584         cmd.block_count = count/3;
3585         cmd.buffer = data;
3586         cmd.instance = file;
3587         cmd.result = -ENODEV;
3588
3589         bttv_call_all(btv, core, ioctl, RDS_CMD_READ, &cmd);
3590
3591         return cmd.result;
3592 }
3593
3594 static unsigned int radio_poll(struct file *file, poll_table *wait)
3595 {
3596         struct bttv_fh *fh = file->private_data;
3597         struct bttv *btv = fh->btv;
3598         struct rds_command cmd;
3599         cmd.instance = file;
3600         cmd.event_list = wait;
3601         cmd.result = -ENODEV;
3602         bttv_call_all(btv, core, ioctl, RDS_CMD_POLL, &cmd);
3603
3604         return cmd.result;
3605 }
3606
3607 static const struct v4l2_file_operations radio_fops =
3608 {
3609         .owner    = THIS_MODULE,
3610         .open     = radio_open,
3611         .read     = radio_read,
3612         .release  = radio_release,
3613         .ioctl    = video_ioctl2,
3614         .poll     = radio_poll,
3615 };
3616
3617 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
3618         .vidioc_querycap        = radio_querycap,
3619         .vidioc_g_tuner         = radio_g_tuner,
3620         .vidioc_enum_input      = radio_enum_input,
3621         .vidioc_g_audio         = radio_g_audio,
3622         .vidioc_s_tuner         = radio_s_tuner,
3623         .vidioc_s_audio         = radio_s_audio,
3624         .vidioc_s_input         = radio_s_input,
3625         .vidioc_s_std           = radio_s_std,
3626         .vidioc_queryctrl       = radio_queryctrl,
3627         .vidioc_g_input         = radio_g_input,
3628         .vidioc_g_ctrl          = bttv_g_ctrl,
3629         .vidioc_s_ctrl          = bttv_s_ctrl,
3630         .vidioc_g_frequency     = bttv_g_frequency,
3631         .vidioc_s_frequency     = bttv_s_frequency,
3632 };
3633
3634 static struct video_device radio_template = {
3635         .fops      = &radio_fops,
3636         .ioctl_ops = &radio_ioctl_ops,
3637 };
3638
3639 /* ----------------------------------------------------------------------- */
3640 /* some debug code                                                         */
3641
3642 static int bttv_risc_decode(u32 risc)
3643 {
3644         static char *instr[16] = {
3645                 [ BT848_RISC_WRITE     >> 28 ] = "write",
3646                 [ BT848_RISC_SKIP      >> 28 ] = "skip",
3647                 [ BT848_RISC_WRITEC    >> 28 ] = "writec",
3648                 [ BT848_RISC_JUMP      >> 28 ] = "jump",
3649                 [ BT848_RISC_SYNC      >> 28 ] = "sync",
3650                 [ BT848_RISC_WRITE123  >> 28 ] = "write123",
3651                 [ BT848_RISC_SKIP123   >> 28 ] = "skip123",
3652                 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3653         };
3654         static int incr[16] = {
3655                 [ BT848_RISC_WRITE     >> 28 ] = 2,
3656                 [ BT848_RISC_JUMP      >> 28 ] = 2,
3657                 [ BT848_RISC_SYNC      >> 28 ] = 2,
3658                 [ BT848_RISC_WRITE123  >> 28 ] = 5,
3659                 [ BT848_RISC_SKIP123   >> 28 ] = 2,
3660                 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3661         };
3662         static char *bits[] = {
3663                 "be0",  "be1",  "be2",  "be3/resync",
3664                 "set0", "set1", "set2", "set3",
3665                 "clr0", "clr1", "clr2", "clr3",
3666                 "irq",  "res",  "eol",  "sol",
3667         };
3668         int i;
3669
3670         printk("0x%08x [ %s", risc,
3671                instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3672         for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3673                 if (risc & (1 << (i + 12)))
3674                         printk(" %s",bits[i]);
3675         printk(" count=%d ]\n", risc & 0xfff);
3676         return incr[risc >> 28] ? incr[risc >> 28] : 1;
3677 }
3678
3679 static void bttv_risc_disasm(struct bttv *btv,
3680                              struct btcx_riscmem *risc)
3681 {
3682         unsigned int i,j,n;
3683
3684         printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3685                btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma);
3686         for (i = 0; i < (risc->size >> 2); i += n) {
3687                 printk("%s:   0x%lx: ", btv->c.v4l2_dev.name,
3688                        (unsigned long)(risc->dma + (i<<2)));
3689                 n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
3690                 for (j = 1; j < n; j++)
3691                         printk("%s:   0x%lx: 0x%08x [ arg #%d ]\n",
3692                                btv->c.v4l2_dev.name, (unsigned long)(risc->dma + ((i+j)<<2)),
3693                                risc->cpu[i+j], j);
3694                 if (0 == risc->cpu[i])
3695                         break;
3696         }
3697 }
3698
3699 static void bttv_print_riscaddr(struct bttv *btv)
3700 {
3701         printk("  main: %08Lx\n",
3702                (unsigned long long)btv->main.dma);
3703         printk("  vbi : o=%08Lx e=%08Lx\n",
3704                btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3705                btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3706         printk("  cap : o=%08Lx e=%08Lx\n",
3707                btv->curr.top    ? (unsigned long long)btv->curr.top->top.dma : 0,
3708                btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3709         printk("  scr : o=%08Lx e=%08Lx\n",
3710                btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3711                btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3712         bttv_risc_disasm(btv, &btv->main);
3713 }
3714
3715 /* ----------------------------------------------------------------------- */
3716 /* irq handler                                                             */
3717
3718 static char *irq_name[] = {
3719         "FMTCHG",  // format change detected (525 vs. 625)
3720         "VSYNC",   // vertical sync (new field)
3721         "HSYNC",   // horizontal sync
3722         "OFLOW",   // chroma/luma AGC overflow
3723         "HLOCK",   // horizontal lock changed
3724         "VPRES",   // video presence changed
3725         "6", "7",
3726         "I2CDONE", // hw irc operation finished
3727         "GPINT",   // gpio port triggered irq
3728         "10",
3729         "RISCI",   // risc instruction triggered irq
3730         "FBUS",    // pixel data fifo dropped data (high pci bus latencies)
3731         "FTRGT",   // pixel data fifo overrun
3732         "FDSR",    // fifo data stream resyncronisation
3733         "PPERR",   // parity error (data transfer)
3734         "RIPERR",  // parity error (read risc instructions)
3735         "PABORT",  // pci abort
3736         "OCERR",   // risc instruction error
3737         "SCERR",   // syncronisation error
3738 };
3739
3740 static void bttv_print_irqbits(u32 print, u32 mark)
3741 {
3742         unsigned int i;
3743
3744         printk("bits:");
3745         for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3746                 if (print & (1 << i))
3747                         printk(" %s",irq_name[i]);
3748                 if (mark & (1 << i))
3749                         printk("*");
3750         }
3751 }
3752
3753 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3754 {
3755         printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3756                btv->c.nr,
3757                (unsigned long)btv->main.dma,
3758                (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
3759                (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
3760                (unsigned long)rc);
3761
3762         if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3763                 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3764                        "Ok, then this is harmless, don't worry ;)\n",
3765                        btv->c.nr);
3766                 return;
3767         }
3768         printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3769                btv->c.nr);
3770         printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3771                btv->c.nr);
3772         dump_stack();
3773 }
3774
3775 static int
3776 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3777 {
3778         struct bttv_buffer *item;
3779
3780         memset(set,0,sizeof(*set));
3781
3782         /* capture request ? */
3783         if (!list_empty(&btv->capture)) {
3784                 set->frame_irq = 1;
3785                 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3786                 if (V4L2_FIELD_HAS_TOP(item->vb.field))
3787                         set->top    = item;
3788                 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3789                         set->bottom = item;
3790
3791                 /* capture request for other field ? */
3792                 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3793                     (item->vb.queue.next != &btv->capture)) {
3794                         item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3795                         /* Mike Isely <isely@pobox.com> - Only check
3796                          * and set up the bottom field in the logic
3797                          * below.  Don't ever do the top field.  This
3798                          * of course means that if we set up the
3799                          * bottom field in the above code that we'll
3800                          * actually skip a field.  But that's OK.
3801                          * Having processed only a single buffer this
3802                          * time, then the next time around the first
3803                          * available buffer should be for a top field.
3804                          * That will then cause us here to set up a
3805                          * top then a bottom field in the normal way.
3806                          * The alternative to this understanding is
3807                          * that we set up the second available buffer
3808                          * as a top field, but that's out of order
3809                          * since this driver always processes the top
3810                          * field first - the effect will be the two
3811                          * buffers being returned in the wrong order,
3812                          * with the second buffer also being delayed
3813                          * by one field time (owing to the fifo nature
3814                          * of videobuf).  Worse still, we'll be stuck
3815                          * doing fields out of order now every time
3816                          * until something else causes a field to be
3817                          * dropped.  By effectively forcing a field to
3818                          * drop this way then we always get back into
3819                          * sync within a single frame time.  (Out of
3820                          * order fields can screw up deinterlacing
3821                          * algorithms.) */
3822                         if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3823                                 if (NULL == set->bottom &&
3824                                     V4L2_FIELD_BOTTOM == item->vb.field) {
3825                                         set->bottom = item;
3826                                 }
3827                                 if (NULL != set->top  &&  NULL != set->bottom)
3828                                         set->top_irq = 2;
3829                         }
3830                 }
3831         }
3832
3833         /* screen overlay ? */
3834         if (NULL != btv->screen) {
3835                 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3836                         if (NULL == set->top && NULL == set->bottom) {
3837                                 set->top    = btv->screen;
3838                                 set->bottom = btv->screen;
3839                         }
3840                 } else {
3841                         if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3842                             NULL == set->top) {
3843                                 set->top = btv->screen;
3844                         }
3845                         if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3846                             NULL == set->bottom) {
3847                                 set->bottom = btv->screen;
3848                         }
3849                 }
3850         }
3851
3852         dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3853                 btv->c.nr,set->top, set->bottom,
3854                 btv->screen,set->frame_irq,set->top_irq);
3855         return 0;
3856 }
3857
3858 static void
3859 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3860                       struct bttv_buffer_set *curr, unsigned int state)
3861 {
3862         struct timeval ts;
3863
3864         do_gettimeofday(&ts);
3865
3866         if (wakeup->top == wakeup->bottom) {
3867                 if (NULL != wakeup->top && curr->top != wakeup->top) {
3868                         if (irq_debug > 1)
3869                                 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
3870                         wakeup->top->vb.ts = ts;
3871                         wakeup->top->vb.field_count = btv->field_count;
3872                         wakeup->top->vb.state = state;
3873                         wake_up(&wakeup->top->vb.done);
3874                 }
3875         } else {
3876                 if (NULL != wakeup->top && curr->top != wakeup->top) {
3877                         if (irq_debug > 1)
3878                                 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
3879                         wakeup->top->vb.ts = ts;
3880                         wakeup->top->vb.field_count = btv->field_count;
3881                         wakeup->top->vb.state = state;
3882                         wake_up(&wakeup->top->vb.done);
3883                 }
3884                 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3885                         if (irq_debug > 1)
3886                                 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
3887                         wakeup->bottom->vb.ts = ts;
3888                         wakeup->bottom->vb.field_count = btv->field_count;
3889                         wakeup->bottom->vb.state = state;
3890                         wake_up(&wakeup->bottom->vb.done);
3891                 }
3892         }
3893 }
3894
3895 static void
3896 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3897                     unsigned int state)
3898 {
3899         struct timeval ts;
3900
3901         if (NULL == wakeup)
3902                 return;
3903
3904         do_gettimeofday(&ts);
3905         wakeup->vb.ts = ts;
3906         wakeup->vb.field_count = btv->field_count;
3907         wakeup->vb.state = state;
3908         wake_up(&wakeup->vb.done);
3909 }
3910
3911 static void bttv_irq_timeout(unsigned long data)
3912 {
3913         struct bttv *btv = (struct bttv *)data;
3914         struct bttv_buffer_set old,new;
3915         struct bttv_buffer *ovbi;
3916         struct bttv_buffer *item;
3917         unsigned long flags;
3918
3919         if (bttv_verbose) {
3920                 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3921                        btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3922                        btread(BT848_RISC_COUNT));
3923                 bttv_print_irqbits(btread(BT848_INT_STAT),0);
3924                 printk("\n");
3925         }
3926
3927         spin_lock_irqsave(&btv->s_lock,flags);
3928
3929         /* deactivate stuff */
3930         memset(&new,0,sizeof(new));
3931         old  = btv->curr;
3932         ovbi = btv->cvbi;
3933         btv->curr = new;
3934         btv->cvbi = NULL;
3935         btv->loop_irq = 0;
3936         bttv_buffer_activate_video(btv, &new);
3937         bttv_buffer_activate_vbi(btv,   NULL);
3938         bttv_set_dma(btv, 0);
3939
3940         /* wake up */
3941         bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
3942         bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
3943
3944         /* cancel all outstanding capture / vbi requests */
3945         while (!list_empty(&btv->capture)) {
3946                 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3947                 list_del(&item->vb.queue);
3948                 item->vb.state = VIDEOBUF_ERROR;
3949                 wake_up(&item->vb.done);
3950         }
3951         while (!list_empty(&btv->vcapture)) {
3952                 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3953                 list_del(&item->vb.queue);
3954                 item->vb.state = VIDEOBUF_ERROR;
3955                 wake_up(&item->vb.done);
3956         }
3957
3958         btv->errors++;
3959         spin_unlock_irqrestore(&btv->s_lock,flags);
3960 }
3961
3962 static void
3963 bttv_irq_wakeup_top(struct bttv *btv)
3964 {
3965         struct bttv_buffer *wakeup = btv->curr.top;
3966
3967         if (NULL == wakeup)
3968                 return;
3969
3970         spin_lock(&btv->s_lock);
3971         btv->curr.top_irq = 0;
3972         btv->curr.top = NULL;
3973         bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3974
3975         do_gettimeofday(&wakeup->vb.ts);
3976         wakeup->vb.field_count = btv->field_count;
3977         wakeup->vb.state = VIDEOBUF_DONE;
3978         wake_up(&wakeup->vb.done);
3979         spin_unlock(&btv->s_lock);
3980 }
3981
3982 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
3983 {
3984         if (rc < risc->dma)
3985                 return 0;
3986         if (rc > risc->dma + risc->size)
3987                 return 0;
3988         return 1;
3989 }
3990
3991 static void
3992 bttv_irq_switch_video(struct bttv *btv)
3993 {
3994         struct bttv_buffer_set new;
3995         struct bttv_buffer_set old;
3996         dma_addr_t rc;
3997
3998         spin_lock(&btv->s_lock);
3999
4000         /* new buffer set */
4001         bttv_irq_next_video(btv, &new);
4002         rc = btread(BT848_RISC_COUNT);
4003         if ((btv->curr.top    && is_active(&btv->curr.top->top,       rc)) ||
4004             (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
4005                 btv->framedrop++;
4006                 if (debug_latency)
4007                         bttv_irq_debug_low_latency(btv, rc);
4008                 spin_unlock(&btv->s_lock);
4009                 return;
4010         }
4011
4012         /* switch over */
4013         old = btv->curr;
4014         btv->curr = new;
4015         btv->loop_irq &= ~1;
4016         bttv_buffer_activate_video(btv, &new);
4017         bttv_set_dma(btv, 0);
4018
4019         /* switch input */
4020         if (UNSET != btv->new_input) {
4021                 video_mux(btv,btv->new_input);
4022                 btv->new_input = UNSET;
4023         }
4024
4025         /* wake up finished buffers */
4026         bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
4027         spin_unlock(&btv->s_lock);
4028 }
4029
4030 static void
4031 bttv_irq_switch_vbi(struct bttv *btv)
4032 {
4033         struct bttv_buffer *new = NULL;
4034         struct bttv_buffer *old;
4035         u32 rc;
4036
4037         spin_lock(&btv->s_lock);
4038
4039         if (!list_empty(&btv->vcapture))
4040                 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4041         old = btv->cvbi;
4042
4043         rc = btread(BT848_RISC_COUNT);
4044         if (NULL != old && (is_active(&old->top,    rc) ||
4045                             is_active(&old->bottom, rc))) {
4046                 btv->framedrop++;
4047                 if (debug_latency)
4048                         bttv_irq_debug_low_latency(btv, rc);
4049                 spin_unlock(&btv->s_lock);
4050                 return;
4051         }
4052
4053         /* switch */
4054         btv->cvbi = new;
4055         btv->loop_irq &= ~4;
4056         bttv_buffer_activate_vbi(btv, new);
4057         bttv_set_dma(btv, 0);
4058
4059         bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
4060         spin_unlock(&btv->s_lock);
4061 }
4062
4063 static irqreturn_t bttv_irq(int irq, void *dev_id)
4064 {
4065         u32 stat,astat;
4066         u32 dstat;
4067         int count;
4068         struct bttv *btv;
4069         int handled = 0;
4070
4071         btv=(struct bttv *)dev_id;
4072
4073         if (btv->custom_irq)
4074                 handled = btv->custom_irq(btv);
4075
4076         count=0;
4077         while (1) {
4078                 /* get/clear interrupt status bits */
4079                 stat=btread(BT848_INT_STAT);
4080                 astat=stat&btread(BT848_INT_MASK);
4081                 if (!astat)
4082                         break;
4083                 handled = 1;
4084                 btwrite(stat,BT848_INT_STAT);
4085
4086                 /* get device status bits */
4087                 dstat=btread(BT848_DSTATUS);
4088
4089                 if (irq_debug) {
4090                         printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
4091                                "riscs=%x, riscc=%08x, ",
4092                                btv->c.nr, count, btv->field_count,
4093                                stat>>28, btread(BT848_RISC_COUNT));
4094                         bttv_print_irqbits(stat,astat);
4095                         if (stat & BT848_INT_HLOCK)
4096                                 printk("   HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
4097                                        ? "yes" : "no");
4098                         if (stat & BT848_INT_VPRES)
4099                                 printk("   PRES => %s", (dstat & BT848_DSTATUS_PRES)
4100                                        ? "yes" : "no");
4101                         if (stat & BT848_INT_FMTCHG)
4102                                 printk("   NUML => %s", (dstat & BT848_DSTATUS_NUML)
4103                                        ? "625" : "525");
4104                         printk("\n");
4105                 }
4106
4107                 if (astat&BT848_INT_VSYNC)
4108                         btv->field_count++;
4109
4110                 if ((astat & BT848_INT_GPINT) && btv->remote) {
4111                         wake_up(&btv->gpioq);
4112                         bttv_input_irq(btv);
4113                 }
4114
4115                 if (astat & BT848_INT_I2CDONE) {
4116                         btv->i2c_done = stat;
4117                         wake_up(&btv->i2c_queue);
4118                 }
4119
4120                 if ((astat & BT848_INT_RISCI)  &&  (stat & (4<<28)))
4121                         bttv_irq_switch_vbi(btv);
4122
4123                 if ((astat & BT848_INT_RISCI)  &&  (stat & (2<<28)))
4124                         bttv_irq_wakeup_top(btv);
4125
4126                 if ((astat & BT848_INT_RISCI)  &&  (stat & (1<<28)))
4127                         bttv_irq_switch_video(btv);
4128
4129                 if ((astat & BT848_INT_HLOCK)  &&  btv->opt_automute)
4130                         audio_mute(btv, btv->mute);  /* trigger automute */
4131
4132                 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
4133                         printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
4134                                (astat & BT848_INT_SCERR) ? "SCERR" : "",
4135                                (astat & BT848_INT_OCERR) ? "OCERR" : "",
4136                                btread(BT848_RISC_COUNT));
4137                         bttv_print_irqbits(stat,astat);
4138                         printk("\n");
4139                         if (bttv_debug)
4140                                 bttv_print_riscaddr(btv);
4141                 }
4142                 if (fdsr && astat & BT848_INT_FDSR) {
4143                         printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
4144                                btv->c.nr,btread(BT848_RISC_COUNT));
4145                         if (bttv_debug)
4146                                 bttv_print_riscaddr(btv);
4147                 }
4148
4149                 count++;
4150                 if (count > 4) {
4151
4152                         if (count > 8 || !(astat & BT848_INT_GPINT)) {
4153                                 btwrite(0, BT848_INT_MASK);
4154
4155                                 printk(KERN_ERR
4156                                            "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
4157                         } else {
4158                                 printk(KERN_ERR
4159                                            "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
4160
4161                                 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
4162                                                 BT848_INT_MASK);
4163                         };
4164
4165                         bttv_print_irqbits(stat,astat);
4166
4167                         printk("]\n");
4168                 }
4169         }
4170         btv->irq_total++;
4171         if (handled)
4172                 btv->irq_me++;
4173         return IRQ_RETVAL(handled);
4174 }
4175
4176
4177 /* ----------------------------------------------------------------------- */
4178 /* initialitation                                                          */
4179
4180 static struct video_device *vdev_init(struct bttv *btv,
4181                                       const struct video_device *template,
4182                                       const char *type_name)
4183 {
4184         struct video_device *vfd;
4185
4186         vfd = video_device_alloc();
4187         if (NULL == vfd)
4188                 return NULL;
4189         *vfd = *template;
4190         vfd->v4l2_dev = &btv->c.v4l2_dev;
4191         vfd->release = video_device_release;
4192         vfd->debug   = bttv_debug;
4193         video_set_drvdata(vfd, btv);
4194         snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
4195                  btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
4196                  type_name, bttv_tvcards[btv->c.type].name);
4197         return vfd;
4198 }
4199
4200 static void bttv_unregister_video(struct bttv *btv)
4201 {
4202         if (btv->video_dev) {
4203                 if (video_is_registered(btv->video_dev))
4204                         video_unregister_device(btv->video_dev);
4205                 else
4206                         video_device_release(btv->video_dev);
4207                 btv->video_dev = NULL;
4208         }
4209         if (btv->vbi_dev) {
4210                 if (video_is_registered(btv->vbi_dev))
4211                         video_unregister_device(btv->vbi_dev);
4212                 else
4213                         video_device_release(btv->vbi_dev);
4214                 btv->vbi_dev = NULL;
4215         }
4216         if (btv->radio_dev) {
4217                 if (video_is_registered(btv->radio_dev))
4218                         video_unregister_device(btv->radio_dev);
4219                 else
4220                         video_device_release(btv->radio_dev);
4221                 btv->radio_dev = NULL;
4222         }
4223 }
4224
4225 /* register video4linux devices */
4226 static int __devinit bttv_register_video(struct bttv *btv)
4227 {
4228         if (no_overlay > 0)
4229                 printk("bttv: Overlay support disabled.\n");
4230
4231         /* video */
4232         btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
4233
4234         if (NULL == btv->video_dev)
4235                 goto err;
4236         if (video_register_device(btv->video_dev, VFL_TYPE_GRABBER,
4237                                   video_nr[btv->c.nr]) < 0)
4238                 goto err;
4239         printk(KERN_INFO "bttv%d: registered device %s\n",
4240                btv->c.nr, video_device_node_name(btv->video_dev));
4241         if (device_create_file(&btv->video_dev->dev,
4242                                      &dev_attr_card)<0) {
4243                 printk(KERN_ERR "bttv%d: device_create_file 'card' "
4244                        "failed\n", btv->c.nr);
4245                 goto err;
4246         }
4247
4248         /* vbi */
4249         btv->vbi_dev = vdev_init(btv, &bttv_video_template, "vbi");
4250
4251         if (NULL == btv->vbi_dev)
4252                 goto err;
4253         if (video_register_device(btv->vbi_dev, VFL_TYPE_VBI,
4254                                   vbi_nr[btv->c.nr]) < 0)
4255                 goto err;
4256         printk(KERN_INFO "bttv%d: registered device %s\n",
4257                btv->c.nr, video_device_node_name(btv->vbi_dev));
4258
4259         if (!btv->has_radio)
4260                 return 0;
4261         /* radio */
4262         btv->radio_dev = vdev_init(btv, &radio_template, "radio");
4263         if (NULL == btv->radio_dev)
4264                 goto err;
4265         if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,
4266                                   radio_nr[btv->c.nr]) < 0)
4267                 goto err;
4268         printk(KERN_INFO "bttv%d: registered device %s\n",
4269                btv->c.nr, video_device_node_name(btv->radio_dev));
4270
4271         /* all done */
4272         return 0;
4273
4274  err:
4275         bttv_unregister_video(btv);
4276         return -1;
4277 }
4278
4279
4280 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
4281 /* response on cards with no firmware is not enabled by OF */
4282 static void pci_set_command(struct pci_dev *dev)
4283 {
4284 #if defined(__powerpc__)
4285         unsigned int cmd;
4286
4287         pci_read_config_dword(dev, PCI_COMMAND, &cmd);
4288         cmd = (cmd | PCI_COMMAND_MEMORY );
4289         pci_write_config_dword(dev, PCI_COMMAND, cmd);
4290 #endif
4291 }
4292
4293 static int __devinit bttv_probe(struct pci_dev *dev,
4294                                 const struct pci_device_id *pci_id)
4295 {
4296         int result;
4297         unsigned char lat;
4298         struct bttv *btv;
4299
4300         if (bttv_num == BTTV_MAX)
4301                 return -ENOMEM;
4302         printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
4303         bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL);
4304         if (btv == NULL) {
4305                 printk(KERN_ERR "bttv: out of memory.\n");
4306                 return -ENOMEM;
4307         }
4308         btv->c.nr  = bttv_num;
4309         snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name),
4310                         "bttv%d", btv->c.nr);
4311
4312         /* initialize structs / fill in defaults */
4313         mutex_init(&btv->lock);
4314         spin_lock_init(&btv->s_lock);
4315         spin_lock_init(&btv->gpio_lock);
4316         init_waitqueue_head(&btv->gpioq);
4317         init_waitqueue_head(&btv->i2c_queue);
4318         INIT_LIST_HEAD(&btv->c.subs);
4319         INIT_LIST_HEAD(&btv->capture);
4320         INIT_LIST_HEAD(&btv->vcapture);
4321         v4l2_prio_init(&btv->prio);
4322
4323         init_timer(&btv->timeout);
4324         btv->timeout.function = bttv_irq_timeout;
4325         btv->timeout.data     = (unsigned long)btv;
4326
4327         btv->i2c_rc = -1;
4328         btv->tuner_type  = UNSET;
4329         btv->new_input   = UNSET;
4330         btv->has_radio=radio[btv->c.nr];
4331
4332         /* pci stuff (init, get irq/mmio, ... */
4333         btv->c.pci = dev;
4334         btv->id  = dev->device;
4335         if (pci_enable_device(dev)) {
4336                 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4337                        btv->c.nr);
4338                 return -EIO;
4339         }
4340         if (pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
4341                 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
4342                        btv->c.nr);
4343                 return -EIO;
4344         }
4345         if (!request_mem_region(pci_resource_start(dev,0),
4346                                 pci_resource_len(dev,0),
4347                                 btv->c.v4l2_dev.name)) {
4348                 printk(KERN_WARNING "bttv%d: can't request iomem (0x%llx).\n",
4349                        btv->c.nr,
4350                        (unsigned long long)pci_resource_start(dev,0));
4351                 return -EBUSY;
4352         }
4353         pci_set_master(dev);
4354         pci_set_command(dev);
4355
4356         result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev);
4357         if (result < 0) {
4358                 printk(KERN_WARNING "bttv%d: v4l2_device_register() failed\n", btv->c.nr);
4359                 goto fail0;
4360         }
4361
4362         pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
4363         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4364         printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
4365                bttv_num,btv->id, btv->revision, pci_name(dev));
4366         printk("irq: %d, latency: %d, mmio: 0x%llx\n",
4367                btv->c.pci->irq, lat,
4368                (unsigned long long)pci_resource_start(dev,0));
4369         schedule();
4370
4371         btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4372         if (NULL == btv->bt848_mmio) {
4373                 printk("bttv%d: ioremap() failed\n", btv->c.nr);
4374                 result = -EIO;
4375                 goto fail1;
4376         }
4377
4378         /* identify card */
4379         bttv_idcard(btv);
4380
4381         /* disable irqs, register irq handler */
4382         btwrite(0, BT848_INT_MASK);
4383         result = request_irq(btv->c.pci->irq, bttv_irq,
4384             IRQF_SHARED | IRQF_DISABLED, btv->c.v4l2_dev.name, (void *)btv);
4385         if (result < 0) {
4386                 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
4387                        bttv_num,btv->c.pci->irq);
4388                 goto fail1;
4389         }
4390
4391         if (0 != bttv_handle_chipset(btv)) {
4392                 result = -EIO;
4393                 goto fail2;
4394         }
4395
4396         /* init options from insmod args */
4397         btv->opt_combfilter = combfilter;
4398         btv->opt_lumafilter = lumafilter;
4399         btv->opt_automute   = automute;
4400         btv->opt_chroma_agc = chroma_agc;
4401         btv->opt_adc_crush  = adc_crush;
4402         btv->opt_vcr_hack   = vcr_hack;
4403         btv->opt_whitecrush_upper  = whitecrush_upper;
4404         btv->opt_whitecrush_lower  = whitecrush_lower;
4405         btv->opt_uv_ratio   = uv_ratio;
4406         btv->opt_full_luma_range   = full_luma_range;
4407         btv->opt_coring     = coring;
4408
4409         /* fill struct bttv with some useful defaults */
4410         btv->init.btv         = btv;
4411         btv->init.ov.w.width  = 320;
4412         btv->init.ov.w.height = 240;
4413         btv->init.fmt         = format_by_fourcc(V4L2_PIX_FMT_BGR24);
4414         btv->init.width       = 320;
4415         btv->init.height      = 240;
4416         btv->input = 0;
4417
4418         /* initialize hardware */
4419         if (bttv_gpio)
4420                 bttv_gpio_tracking(btv,"pre-init");
4421
4422         bttv_risc_init_main(btv);
4423         init_bt848(btv);
4424
4425         /* gpio */
4426         btwrite(0x00, BT848_GPIO_REG_INP);
4427         btwrite(0x00, BT848_GPIO_OUT_EN);
4428         if (bttv_verbose)
4429                 bttv_gpio_tracking(btv,"init");
4430
4431         /* needs to be done before i2c is registered */
4432         bttv_init_card1(btv);
4433
4434         /* register i2c + gpio */
4435         init_bttv_i2c(btv);
4436
4437         /* some card-specific stuff (needs working i2c) */
4438         bttv_init_card2(btv);
4439         bttv_init_tuner(btv);
4440         init_irqreg(btv);
4441
4442         /* register video4linux + input */
4443         if (!bttv_tvcards[btv->c.type].no_video) {
4444                 bttv_register_video(btv);
4445                 bt848_bright(btv,32768);
4446                 bt848_contrast(btv,32768);
4447                 bt848_hue(btv,32768);
4448                 bt848_sat(btv,32768);
4449                 audio_mute(btv, 1);
4450                 set_input(btv, 0, btv->tvnorm);
4451                 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4452                 btv->crop[1] = btv->crop[0]; /* current = default */
4453                 disclaim_vbi_lines(btv);
4454                 disclaim_video_lines(btv);
4455         }
4456
4457         /* add subdevices and autoload dvb-bt8xx if needed */
4458         if (bttv_tvcards[btv->c.type].has_dvb) {
4459                 bttv_sub_add_device(&btv->c, "dvb");
4460                 request_modules(btv);
4461         }
4462
4463         if (!disable_ir) {
4464                 init_bttv_i2c_ir(btv);
4465                 bttv_input_init(btv);
4466         }
4467
4468         /* everything is fine */
4469         bttv_num++;
4470         return 0;
4471
4472 fail2:
4473         free_irq(btv->c.pci->irq,btv);
4474
4475 fail1:
4476         v4l2_device_unregister(&btv->c.v4l2_dev);
4477
4478 fail0:
4479         if (btv->bt848_mmio)
4480                 iounmap(btv->bt848_mmio);
4481         release_mem_region(pci_resource_start(btv->c.pci,0),
4482                            pci_resource_len(btv->c.pci,0));
4483         return result;
4484 }
4485
4486 static void __devexit bttv_remove(struct pci_dev *pci_dev)
4487 {
4488         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4489         struct bttv *btv = to_bttv(v4l2_dev);
4490
4491         if (bttv_verbose)
4492                 printk("bttv%d: unloading\n",btv->c.nr);
4493
4494         /* shutdown everything (DMA+IRQs) */
4495         btand(~15, BT848_GPIO_DMA_CTL);
4496         btwrite(0, BT848_INT_MASK);
4497         btwrite(~0x0, BT848_INT_STAT);
4498         btwrite(0x0, BT848_GPIO_OUT_EN);
4499         if (bttv_gpio)
4500                 bttv_gpio_tracking(btv,"cleanup");
4501
4502         /* tell gpio modules we are leaving ... */
4503         btv->shutdown=1;
4504         wake_up(&btv->gpioq);
4505         bttv_input_fini(btv);
4506         bttv_sub_del_devices(&btv->c);
4507
4508         /* unregister i2c_bus + input */
4509         fini_bttv_i2c(btv);
4510
4511         /* unregister video4linux */
4512         bttv_unregister_video(btv);
4513
4514         /* free allocated memory */
4515         btcx_riscmem_free(btv->c.pci,&btv->main);
4516
4517         /* free ressources */
4518         free_irq(btv->c.pci->irq,btv);
4519         iounmap(btv->bt848_mmio);
4520         release_mem_region(pci_resource_start(btv->c.pci,0),
4521                            pci_resource_len(btv->c.pci,0));
4522
4523         v4l2_device_unregister(&btv->c.v4l2_dev);
4524         bttvs[btv->c.nr] = NULL;
4525         kfree(btv);
4526
4527         return;
4528 }
4529
4530 #ifdef CONFIG_PM
4531 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4532 {
4533         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4534         struct bttv *btv = to_bttv(v4l2_dev);
4535         struct bttv_buffer_set idle;
4536         unsigned long flags;
4537
4538         dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
4539
4540         /* stop dma + irqs */
4541         spin_lock_irqsave(&btv->s_lock,flags);
4542         memset(&idle, 0, sizeof(idle));
4543         btv->state.video = btv->curr;
4544         btv->state.vbi   = btv->cvbi;
4545         btv->state.loop_irq = btv->loop_irq;
4546         btv->curr = idle;
4547         btv->loop_irq = 0;
4548         bttv_buffer_activate_video(btv, &idle);
4549         bttv_buffer_activate_vbi(btv, NULL);
4550         bttv_set_dma(btv, 0);
4551         btwrite(0, BT848_INT_MASK);
4552         spin_unlock_irqrestore(&btv->s_lock,flags);
4553
4554         /* save bt878 state */
4555         btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4556         btv->state.gpio_data   = gpio_read();
4557
4558         /* save pci state */
4559         pci_save_state(pci_dev);
4560         if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4561                 pci_disable_device(pci_dev);
4562                 btv->state.disabled = 1;
4563         }
4564         return 0;
4565 }
4566
4567 static int bttv_resume(struct pci_dev *pci_dev)
4568 {
4569         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4570         struct bttv *btv = to_bttv(v4l2_dev);
4571         unsigned long flags;
4572         int err;
4573
4574         dprintk("bttv%d: resume\n", btv->c.nr);
4575
4576         /* restore pci state */
4577         if (btv->state.disabled) {
4578                 err=pci_enable_device(pci_dev);
4579                 if (err) {
4580                         printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4581                                                                 btv->c.nr);
4582                         return err;
4583                 }
4584                 btv->state.disabled = 0;
4585         }
4586         err=pci_set_power_state(pci_dev, PCI_D0);
4587         if (err) {
4588                 pci_disable_device(pci_dev);
4589                 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4590                                                         btv->c.nr);
4591                 btv->state.disabled = 1;
4592                 return err;
4593         }
4594
4595         pci_restore_state(pci_dev);
4596
4597         /* restore bt878 state */
4598         bttv_reinit_bt848(btv);
4599         gpio_inout(0xffffff, btv->state.gpio_enable);
4600         gpio_write(btv->state.gpio_data);
4601
4602         /* restart dma */
4603         spin_lock_irqsave(&btv->s_lock,flags);
4604         btv->curr = btv->state.video;
4605         btv->cvbi = btv->state.vbi;
4606         btv->loop_irq = btv->state.loop_irq;
4607         bttv_buffer_activate_video(btv, &btv->curr);
4608         bttv_buffer_activate_vbi(btv, btv->cvbi);
4609         bttv_set_dma(btv, 0);
4610         spin_unlock_irqrestore(&btv->s_lock,flags);
4611         return 0;
4612 }
4613 #endif
4614
4615 static struct pci_device_id bttv_pci_tbl[] = {
4616         {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0},
4617         {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0},
4618         {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0},
4619         {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0},
4620         {0,}
4621 };
4622
4623 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4624
4625 static struct pci_driver bttv_pci_driver = {
4626         .name     = "bttv",
4627         .id_table = bttv_pci_tbl,
4628         .probe    = bttv_probe,
4629         .remove   = __devexit_p(bttv_remove),
4630 #ifdef CONFIG_PM
4631         .suspend  = bttv_suspend,
4632         .resume   = bttv_resume,
4633 #endif
4634 };
4635
4636 static int __init bttv_init_module(void)
4637 {
4638         int ret;
4639
4640         bttv_num = 0;
4641
4642         printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4643                (BTTV_VERSION_CODE >> 16) & 0xff,
4644                (BTTV_VERSION_CODE >> 8) & 0xff,
4645                BTTV_VERSION_CODE & 0xff);
4646 #ifdef SNAPSHOT
4647         printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4648                SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4649 #endif
4650         if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4651                 gbuffers = 2;
4652         if (gbufsize > BTTV_MAX_FBUF)
4653                 gbufsize = BTTV_MAX_FBUF;
4654         gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4655         if (bttv_verbose)
4656                 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4657                        gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4658
4659         bttv_check_chipset();
4660
4661         ret = bus_register(&bttv_sub_bus_type);
4662         if (ret < 0) {
4663                 printk(KERN_WARNING "bttv: bus_register error: %d\n", ret);
4664                 return ret;
4665         }
4666         ret = pci_register_driver(&bttv_pci_driver);
4667         if (ret < 0)
4668                 bus_unregister(&bttv_sub_bus_type);
4669
4670         return ret;
4671 }
4672
4673 static void __exit bttv_cleanup_module(void)
4674 {
4675         pci_unregister_driver(&bttv_pci_driver);
4676         bus_unregister(&bttv_sub_bus_type);
4677 }
4678
4679 module_init(bttv_init_module);
4680 module_exit(bttv_cleanup_module);
4681
4682 /*
4683  * Local variables:
4684  * c-basic-offset: 8
4685  * End:
4686  */