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

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