git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/bt8xx/bttv-driver.c

   1 /*
   2
   3     bttv - Bt848 frame grabber driver
   4
   5     Copyright (C) 1996,97,98 Ralph  Metzler <rjkm@thp.uni-koeln.de>
   6                            & Marcus Metzler <mocm@thp.uni-koeln.de>
   7     (c) 1999-2002 Gerd Knorr <kraxel@bytesex.org>
   8
   9     some v4l2 code lines are taken from Justin's bttv2 driver which is
  10     (c) 2000 Justin Schoeman <justin@suntiger.ee.up.ac.za>
  11
  12     V4L1 removal from:
  13     (c) 2005-2006 Nickolay V. Shmyrev <nshmyrev@yandex.ru>
  14
  15     Fixes to be fully V4L2 compliant by
  16     (c) 2006 Mauro Carvalho Chehab <mchehab@infradead.org>
  17
  18     Cropping and overscan support
  19     Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
  20     Sponsored by OPQ Systems AB
  21
  22     This program is free software; you can redistribute it and/or modify
  23     it under the terms of the GNU General Public License as published by
  24     the Free Software Foundation; either version 2 of the License, or
  25     (at your option) any later version.
  26
  27     This program is distributed in the hope that it will be useful,
  28     but WITHOUT ANY WARRANTY; without even the implied warranty of
  29     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30     GNU General Public License for more details.
  31
  32     You should have received a copy of the GNU General Public License
  33     along with this program; if not, write to the Free Software
  34     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  35 */
  36
  37 #include <linux/init.h>
  38 #include <linux/module.h>
  39 #include <linux/delay.h>
  40 #include <linux/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 (UNSET == bttv_tvcards[btv->c.type].muxsel[btv->input]) {
1044                 dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
1045                         btv->c.nr,table_idx);
1046
1047                 /* timing change...reset timing generator address */
1048                 btwrite(0x00, BT848_TGCTRL);
1049                 btwrite(0x02, BT848_TGCTRL);
1050                 btwrite(0x00, BT848_TGCTRL);
1051
1052                 len=SRAM_Table[table_idx][0];
1053                 for(i = 1; i <= len; i++)
1054                         btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
1055                 btv->pll.pll_ofreq = 27000000;
1056
1057                 set_pll(btv);
1058                 btwrite(0x11, BT848_TGCTRL);
1059                 btwrite(0x41, BT848_DVSIF);
1060         } else {
1061                 btv->pll.pll_ofreq = fsc;
1062                 set_pll(btv);
1063                 btwrite(0x0, BT848_DVSIF);
1064         }
1065 }
1066
1067 /* ----------------------------------------------------------------------- */
1068
1069 static void bt848_bright(struct bttv *btv, int bright)
1070 {
1071         int value;
1072
1073         // printk("bttv: set bright: %d\n",bright); // DEBUG
1074         btv->bright = bright;
1075
1076         /* We want -128 to 127 we get 0-65535 */
1077         value = (bright >> 8) - 128;
1078         btwrite(value & 0xff, BT848_BRIGHT);
1079 }
1080
1081 static void bt848_hue(struct bttv *btv, int hue)
1082 {
1083         int value;
1084
1085         btv->hue = hue;
1086
1087         /* -128 to 127 */
1088         value = (hue >> 8) - 128;
1089         btwrite(value & 0xff, BT848_HUE);
1090 }
1091
1092 static void bt848_contrast(struct bttv *btv, int cont)
1093 {
1094         int value,hibit;
1095
1096         btv->contrast = cont;
1097
1098         /* 0-511 */
1099         value = (cont  >> 7);
1100         hibit = (value >> 6) & 4;
1101         btwrite(value & 0xff, BT848_CONTRAST_LO);
1102         btaor(hibit, ~4, BT848_E_CONTROL);
1103         btaor(hibit, ~4, BT848_O_CONTROL);
1104 }
1105
1106 static void bt848_sat(struct bttv *btv, int color)
1107 {
1108         int val_u,val_v,hibits;
1109
1110         btv->saturation = color;
1111
1112         /* 0-511 for the color */
1113         val_u   = ((color * btv->opt_uv_ratio) / 50) >> 7;
1114         val_v   = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
1115         hibits  = (val_u >> 7) & 2;
1116         hibits |= (val_v >> 8) & 1;
1117         btwrite(val_u & 0xff, BT848_SAT_U_LO);
1118         btwrite(val_v & 0xff, BT848_SAT_V_LO);
1119         btaor(hibits, ~3, BT848_E_CONTROL);
1120         btaor(hibits, ~3, BT848_O_CONTROL);
1121 }
1122
1123 /* ----------------------------------------------------------------------- */
1124
1125 static int
1126 video_mux(struct bttv *btv, unsigned int input)
1127 {
1128         int mux,mask2;
1129
1130         if (input >= bttv_tvcards[btv->c.type].video_inputs)
1131                 return -EINVAL;
1132
1133         /* needed by RemoteVideo MX */
1134         mask2 = bttv_tvcards[btv->c.type].gpiomask2;
1135         if (mask2)
1136                 gpio_inout(mask2,mask2);
1137
1138         if (input == btv->svhs)  {
1139                 btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
1140                 btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
1141         } else {
1142                 btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
1143                 btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
1144         }
1145         mux = bttv_tvcards[btv->c.type].muxsel[input] & 3;
1146         btaor(mux<<5, ~(3<<5), BT848_IFORM);
1147         dprintk(KERN_DEBUG "bttv%d: video mux: input=%d mux=%d\n",
1148                 btv->c.nr,input,mux);
1149
1150         /* card specific hook */
1151         if(bttv_tvcards[btv->c.type].muxsel_hook)
1152                 bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
1153         return 0;
1154 }
1155
1156 static char *audio_modes[] = {
1157         "audio: tuner", "audio: radio", "audio: extern",
1158         "audio: intern", "audio: mute"
1159 };
1160
1161 static int
1162 audio_mux(struct bttv *btv, int input, int mute)
1163 {
1164         int gpio_val, signal;
1165         struct v4l2_control ctrl;
1166         struct i2c_client *c;
1167
1168         gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
1169                    bttv_tvcards[btv->c.type].gpiomask);
1170         signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
1171
1172         btv->mute = mute;
1173         btv->audio = input;
1174
1175         /* automute */
1176         mute = mute || (btv->opt_automute && !signal && !btv->radio_user);
1177
1178         if (mute)
1179                 gpio_val = bttv_tvcards[btv->c.type].gpiomute;
1180         else
1181                 gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
1182
1183         gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
1184         if (bttv_gpio)
1185                 bttv_gpio_tracking(btv, audio_modes[mute ? 4 : input]);
1186         if (in_interrupt())
1187                 return 0;
1188
1189         ctrl.id = V4L2_CID_AUDIO_MUTE;
1190         ctrl.value = btv->mute;
1191         bttv_call_i2c_clients(btv, VIDIOC_S_CTRL, &ctrl);
1192         c = btv->i2c_msp34xx_client;
1193         if (c) {
1194                 struct v4l2_routing route;
1195
1196                 /* Note: the inputs tuner/radio/extern/intern are translated
1197                    to msp routings. This assumes common behavior for all msp3400
1198                    based TV cards. When this assumption fails, then the
1199                    specific MSP routing must be added to the card table.
1200                    For now this is sufficient. */
1201                 switch (input) {
1202                 case TVAUDIO_INPUT_RADIO:
1203                         route.input = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1204                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1205                         break;
1206                 case TVAUDIO_INPUT_EXTERN:
1207                         route.input = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
1208                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1209                         break;
1210                 case TVAUDIO_INPUT_INTERN:
1211                         /* Yes, this is the same input as for RADIO. I doubt
1212                            if this is ever used. The only board with an INTERN
1213                            input is the BTTV_BOARD_AVERMEDIA98. I wonder how
1214                            that was tested. My guess is that the whole INTERN
1215                            input does not work. */
1216                         route.input = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1217                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1218                         break;
1219                 case TVAUDIO_INPUT_TUNER:
1220                 default:
1221                         /* This is the only card that uses TUNER2, and afaik,
1222                            is the only difference between the VOODOOTV_FM
1223                            and VOODOOTV_200 */
1224                         if (btv->c.type == BTTV_BOARD_VOODOOTV_200)
1225                                 route.input = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \
1226                                         MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER);
1227                         else
1228                                 route.input = MSP_INPUT_DEFAULT;
1229                         break;
1230                 }
1231                 route.output = MSP_OUTPUT_DEFAULT;
1232                 c->driver->command(c, VIDIOC_INT_S_AUDIO_ROUTING, &route);
1233         }
1234         c = btv->i2c_tvaudio_client;
1235         if (c) {
1236                 struct v4l2_routing route;
1237
1238                 route.input = input;
1239                 route.output = 0;
1240                 c->driver->command(c, VIDIOC_INT_S_AUDIO_ROUTING, &route);
1241         }
1242         return 0;
1243 }
1244
1245 static inline int
1246 audio_mute(struct bttv *btv, int mute)
1247 {
1248         return audio_mux(btv, btv->audio, mute);
1249 }
1250
1251 static inline int
1252 audio_input(struct bttv *btv, int input)
1253 {
1254         return audio_mux(btv, input, btv->mute);
1255 }
1256
1257 static void
1258 bttv_crop_calc_limits(struct bttv_crop *c)
1259 {
1260         /* Scale factor min. 1:1, max. 16:1. Min. image size
1261            48 x 32. Scaled width must be a multiple of 4. */
1262
1263         if (1) {
1264                 /* For bug compatibility with VIDIOCGCAP and image
1265                    size checks in earlier driver versions. */
1266                 c->min_scaled_width = 48;
1267                 c->min_scaled_height = 32;
1268         } else {
1269                 c->min_scaled_width =
1270                         (max(48, c->rect.width >> 4) + 3) & ~3;
1271                 c->min_scaled_height =
1272                         max(32, c->rect.height >> 4);
1273         }
1274
1275         c->max_scaled_width  = c->rect.width & ~3;
1276         c->max_scaled_height = c->rect.height;
1277 }
1278
1279 static void
1280 bttv_crop_reset(struct bttv_crop *c, int norm)
1281 {
1282         c->rect = bttv_tvnorms[norm].cropcap.defrect;
1283         bttv_crop_calc_limits(c);
1284 }
1285
1286 /* Call with btv->lock down. */
1287 static int
1288 set_tvnorm(struct bttv *btv, unsigned int norm)
1289 {
1290         const struct bttv_tvnorm *tvnorm;
1291         v4l2_std_id id;
1292
1293         if (norm < 0 || norm >= BTTV_TVNORMS)
1294                 return -EINVAL;
1295
1296         tvnorm = &bttv_tvnorms[norm];
1297
1298         if (btv->tvnorm < 0 ||
1299             btv->tvnorm >= BTTV_TVNORMS ||
1300             0 != memcmp(&bttv_tvnorms[btv->tvnorm].cropcap,
1301                         &tvnorm->cropcap,
1302                         sizeof (tvnorm->cropcap))) {
1303                 bttv_crop_reset(&btv->crop[0], norm);
1304                 btv->crop[1] = btv->crop[0]; /* current = default */
1305
1306                 if (0 == (btv->resources & VIDEO_RESOURCES)) {
1307                         btv->crop_start = tvnorm->cropcap.bounds.top
1308                                 + tvnorm->cropcap.bounds.height;
1309                 }
1310         }
1311
1312         btv->tvnorm = norm;
1313
1314         btwrite(tvnorm->adelay, BT848_ADELAY);
1315         btwrite(tvnorm->bdelay, BT848_BDELAY);
1316         btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1317               BT848_IFORM);
1318         btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1319         btwrite(1, BT848_VBI_PACK_DEL);
1320         bt848A_set_timing(btv);
1321
1322         switch (btv->c.type) {
1323         case BTTV_BOARD_VOODOOTV_FM:
1324         case BTTV_BOARD_VOODOOTV_200:
1325                 bttv_tda9880_setnorm(btv,norm);
1326                 break;
1327         }
1328         id = tvnorm->v4l2_id;
1329         bttv_call_i2c_clients(btv, VIDIOC_S_STD, &id);
1330
1331         return 0;
1332 }
1333
1334 /* Call with btv->lock down. */
1335 static void
1336 set_input(struct bttv *btv, unsigned int input, unsigned int norm)
1337 {
1338         unsigned long flags;
1339
1340         btv->input = input;
1341         if (irq_iswitch) {
1342                 spin_lock_irqsave(&btv->s_lock,flags);
1343                 if (btv->curr.frame_irq) {
1344                         /* active capture -> delayed input switch */
1345                         btv->new_input = input;
1346                 } else {
1347                         video_mux(btv,input);
1348                 }
1349                 spin_unlock_irqrestore(&btv->s_lock,flags);
1350         } else {
1351                 video_mux(btv,input);
1352         }
1353         audio_input(btv,(input == bttv_tvcards[btv->c.type].tuner ?
1354                        TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN));
1355         set_tvnorm(btv, norm);
1356 }
1357
1358 static void init_irqreg(struct bttv *btv)
1359 {
1360         /* clear status */
1361         btwrite(0xfffffUL, BT848_INT_STAT);
1362
1363         if (bttv_tvcards[btv->c.type].no_video) {
1364                 /* i2c only */
1365                 btwrite(BT848_INT_I2CDONE,
1366                         BT848_INT_MASK);
1367         } else {
1368                 /* full video */
1369                 btwrite((btv->triton1)  |
1370                         (btv->gpioirq ? BT848_INT_GPINT : 0) |
1371                         BT848_INT_SCERR |
1372                         (fdsr ? BT848_INT_FDSR : 0) |
1373                         BT848_INT_RISCI | BT848_INT_OCERR |
1374                         BT848_INT_FMTCHG|BT848_INT_HLOCK|
1375                         BT848_INT_I2CDONE,
1376                         BT848_INT_MASK);
1377         }
1378 }
1379
1380 static void init_bt848(struct bttv *btv)
1381 {
1382         int val;
1383
1384         if (bttv_tvcards[btv->c.type].no_video) {
1385                 /* very basic init only */
1386                 init_irqreg(btv);
1387                 return;
1388         }
1389
1390         btwrite(0x00, BT848_CAP_CTL);
1391         btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1392         btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1393
1394         /* set planar and packed mode trigger points and         */
1395         /* set rising edge of inverted GPINTR pin as irq trigger */
1396         btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1397                 BT848_GPIO_DMA_CTL_PLTP1_16|
1398                 BT848_GPIO_DMA_CTL_PLTP23_16|
1399                 BT848_GPIO_DMA_CTL_GPINTC|
1400                 BT848_GPIO_DMA_CTL_GPINTI,
1401                 BT848_GPIO_DMA_CTL);
1402
1403         val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1404         btwrite(val, BT848_E_SCLOOP);
1405         btwrite(val, BT848_O_SCLOOP);
1406
1407         btwrite(0x20, BT848_E_VSCALE_HI);
1408         btwrite(0x20, BT848_O_VSCALE_HI);
1409         btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1410                 BT848_ADC);
1411
1412         btwrite(whitecrush_upper, BT848_WC_UP);
1413         btwrite(whitecrush_lower, BT848_WC_DOWN);
1414
1415         if (btv->opt_lumafilter) {
1416                 btwrite(0, BT848_E_CONTROL);
1417                 btwrite(0, BT848_O_CONTROL);
1418         } else {
1419                 btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1420                 btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1421         }
1422
1423         bt848_bright(btv,   btv->bright);
1424         bt848_hue(btv,      btv->hue);
1425         bt848_contrast(btv, btv->contrast);
1426         bt848_sat(btv,      btv->saturation);
1427
1428         /* interrupt */
1429         init_irqreg(btv);
1430 }
1431
1432 static void bttv_reinit_bt848(struct bttv *btv)
1433 {
1434         unsigned long flags;
1435
1436         if (bttv_verbose)
1437                 printk(KERN_INFO "bttv%d: reset, reinitialize\n",btv->c.nr);
1438         spin_lock_irqsave(&btv->s_lock,flags);
1439         btv->errors=0;
1440         bttv_set_dma(btv,0);
1441         spin_unlock_irqrestore(&btv->s_lock,flags);
1442
1443         init_bt848(btv);
1444         btv->pll.pll_current = -1;
1445         set_input(btv, btv->input, btv->tvnorm);
1446 }
1447
1448 static int bttv_g_ctrl(struct file *file, void *priv,
1449                                         struct v4l2_control *c)
1450 {
1451         struct bttv_fh *fh = priv;
1452         struct bttv *btv = fh->btv;
1453
1454         switch (c->id) {
1455         case V4L2_CID_BRIGHTNESS:
1456                 c->value = btv->bright;
1457                 break;
1458         case V4L2_CID_HUE:
1459                 c->value = btv->hue;
1460                 break;
1461         case V4L2_CID_CONTRAST:
1462                 c->value = btv->contrast;
1463                 break;
1464         case V4L2_CID_SATURATION:
1465                 c->value = btv->saturation;
1466                 break;
1467
1468         case V4L2_CID_AUDIO_MUTE:
1469         case V4L2_CID_AUDIO_VOLUME:
1470         case V4L2_CID_AUDIO_BALANCE:
1471         case V4L2_CID_AUDIO_BASS:
1472         case V4L2_CID_AUDIO_TREBLE:
1473                 bttv_call_i2c_clients(btv, VIDIOC_G_CTRL, c);
1474                 break;
1475
1476         case V4L2_CID_PRIVATE_CHROMA_AGC:
1477                 c->value = btv->opt_chroma_agc;
1478                 break;
1479         case V4L2_CID_PRIVATE_COMBFILTER:
1480                 c->value = btv->opt_combfilter;
1481                 break;
1482         case V4L2_CID_PRIVATE_LUMAFILTER:
1483                 c->value = btv->opt_lumafilter;
1484                 break;
1485         case V4L2_CID_PRIVATE_AUTOMUTE:
1486                 c->value = btv->opt_automute;
1487                 break;
1488         case V4L2_CID_PRIVATE_AGC_CRUSH:
1489                 c->value = btv->opt_adc_crush;
1490                 break;
1491         case V4L2_CID_PRIVATE_VCR_HACK:
1492                 c->value = btv->opt_vcr_hack;
1493                 break;
1494         case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1495                 c->value = btv->opt_whitecrush_upper;
1496                 break;
1497         case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1498                 c->value = btv->opt_whitecrush_lower;
1499                 break;
1500         case V4L2_CID_PRIVATE_UV_RATIO:
1501                 c->value = btv->opt_uv_ratio;
1502                 break;
1503         case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1504                 c->value = btv->opt_full_luma_range;
1505                 break;
1506         case V4L2_CID_PRIVATE_CORING:
1507                 c->value = btv->opt_coring;
1508                 break;
1509         default:
1510                 return -EINVAL;
1511         }
1512         return 0;
1513 }
1514
1515 static int bttv_s_ctrl(struct file *file, void *f,
1516                                         struct v4l2_control *c)
1517 {
1518         int err;
1519         int val;
1520         struct bttv_fh *fh = f;
1521         struct bttv *btv = fh->btv;
1522
1523         err = v4l2_prio_check(&btv->prio, &fh->prio);
1524         if (0 != err)
1525                 return err;
1526
1527         switch (c->id) {
1528         case V4L2_CID_BRIGHTNESS:
1529                 bt848_bright(btv, c->value);
1530                 break;
1531         case V4L2_CID_HUE:
1532                 bt848_hue(btv, c->value);
1533                 break;
1534         case V4L2_CID_CONTRAST:
1535                 bt848_contrast(btv, c->value);
1536                 break;
1537         case V4L2_CID_SATURATION:
1538                 bt848_sat(btv, c->value);
1539                 break;
1540         case V4L2_CID_AUDIO_MUTE:
1541                 audio_mute(btv, c->value);
1542                 /* fall through */
1543         case V4L2_CID_AUDIO_VOLUME:
1544                 if (btv->volume_gpio)
1545                         btv->volume_gpio(btv, c->value);
1546
1547                 bttv_call_i2c_clients(btv, VIDIOC_S_CTRL, c);
1548                 break;
1549         case V4L2_CID_AUDIO_BALANCE:
1550         case V4L2_CID_AUDIO_BASS:
1551         case V4L2_CID_AUDIO_TREBLE:
1552                 bttv_call_i2c_clients(btv, VIDIOC_S_CTRL, c);
1553                 break;
1554
1555         case V4L2_CID_PRIVATE_CHROMA_AGC:
1556                 btv->opt_chroma_agc = c->value;
1557                 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1558                 btwrite(val, BT848_E_SCLOOP);
1559                 btwrite(val, BT848_O_SCLOOP);
1560                 break;
1561         case V4L2_CID_PRIVATE_COMBFILTER:
1562                 btv->opt_combfilter = c->value;
1563                 break;
1564         case V4L2_CID_PRIVATE_LUMAFILTER:
1565                 btv->opt_lumafilter = c->value;
1566                 if (btv->opt_lumafilter) {
1567                         btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1568                         btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1569                 } else {
1570                         btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1571                         btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1572                 }
1573                 break;
1574         case V4L2_CID_PRIVATE_AUTOMUTE:
1575                 btv->opt_automute = c->value;
1576                 break;
1577         case V4L2_CID_PRIVATE_AGC_CRUSH:
1578                 btv->opt_adc_crush = c->value;
1579                 btwrite(BT848_ADC_RESERVED |
1580                                 (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1581                                 BT848_ADC);
1582                 break;
1583         case V4L2_CID_PRIVATE_VCR_HACK:
1584                 btv->opt_vcr_hack = c->value;
1585                 break;
1586         case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1587                 btv->opt_whitecrush_upper = c->value;
1588                 btwrite(c->value, BT848_WC_UP);
1589                 break;
1590         case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1591                 btv->opt_whitecrush_lower = c->value;
1592                 btwrite(c->value, BT848_WC_DOWN);
1593                 break;
1594         case V4L2_CID_PRIVATE_UV_RATIO:
1595                 btv->opt_uv_ratio = c->value;
1596                 bt848_sat(btv, btv->saturation);
1597                 break;
1598         case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1599                 btv->opt_full_luma_range = c->value;
1600                 btaor((c->value<<7), ~BT848_OFORM_RANGE, BT848_OFORM);
1601                 break;
1602         case V4L2_CID_PRIVATE_CORING:
1603                 btv->opt_coring = c->value;
1604                 btaor((c->value<<5), ~BT848_OFORM_CORE32, BT848_OFORM);
1605                 break;
1606         default:
1607                 return -EINVAL;
1608         }
1609         return 0;
1610 }
1611
1612 /* ----------------------------------------------------------------------- */
1613
1614 void bttv_gpio_tracking(struct bttv *btv, char *comment)
1615 {
1616         unsigned int outbits, data;
1617         outbits = btread(BT848_GPIO_OUT_EN);
1618         data    = btread(BT848_GPIO_DATA);
1619         printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1620                btv->c.nr,outbits,data & outbits, data & ~outbits, comment);
1621 }
1622
1623 static void bttv_field_count(struct bttv *btv)
1624 {
1625         int need_count = 0;
1626
1627         if (btv->users)
1628                 need_count++;
1629
1630         if (need_count) {
1631                 /* start field counter */
1632                 btor(BT848_INT_VSYNC,BT848_INT_MASK);
1633         } else {
1634                 /* stop field counter */
1635                 btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1636                 btv->field_count = 0;
1637         }
1638 }
1639
1640 static const struct bttv_format*
1641 format_by_fourcc(int fourcc)
1642 {
1643         unsigned int i;
1644
1645         for (i = 0; i < FORMATS; i++) {
1646                 if (-1 == formats[i].fourcc)
1647                         continue;
1648                 if (formats[i].fourcc == fourcc)
1649                         return formats+i;
1650         }
1651         return NULL;
1652 }
1653
1654 /* ----------------------------------------------------------------------- */
1655 /* misc helpers                                                            */
1656
1657 static int
1658 bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1659                     struct bttv_buffer *new)
1660 {
1661         struct bttv_buffer *old;
1662         unsigned long flags;
1663         int retval = 0;
1664
1665         dprintk("switch_overlay: enter [new=%p]\n",new);
1666         if (new)
1667                 new->vb.state = VIDEOBUF_DONE;
1668         spin_lock_irqsave(&btv->s_lock,flags);
1669         old = btv->screen;
1670         btv->screen = new;
1671         btv->loop_irq |= 1;
1672         bttv_set_dma(btv, 0x03);
1673         spin_unlock_irqrestore(&btv->s_lock,flags);
1674         if (NULL != old) {
1675                 dprintk("switch_overlay: old=%p state is %d\n",old,old->vb.state);
1676                 bttv_dma_free(&fh->cap,btv, old);
1677                 kfree(old);
1678         }
1679         if (NULL == new)
1680                 free_btres(btv,fh,RESOURCE_OVERLAY);
1681         dprintk("switch_overlay: done\n");
1682         return retval;
1683 }
1684
1685 /* ----------------------------------------------------------------------- */
1686 /* video4linux (1) interface                                               */
1687
1688 static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1689                                struct bttv_buffer *buf,
1690                                const struct bttv_format *fmt,
1691                                unsigned int width, unsigned int height,
1692                                enum v4l2_field field)
1693 {
1694         struct bttv_fh *fh = q->priv_data;
1695         int redo_dma_risc = 0;
1696         struct bttv_crop c;
1697         int norm;
1698         int rc;
1699
1700         /* check settings */
1701         if (NULL == fmt)
1702                 return -EINVAL;
1703         if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1704                 width  = RAW_BPL;
1705                 height = RAW_LINES*2;
1706                 if (width*height > buf->vb.bsize)
1707                         return -EINVAL;
1708                 buf->vb.size = buf->vb.bsize;
1709
1710                 /* Make sure tvnorm and vbi_end remain consistent
1711                    until we're done. */
1712                 mutex_lock(&btv->lock);
1713
1714                 norm = btv->tvnorm;
1715
1716                 /* In this mode capturing always starts at defrect.top
1717                    (default VDELAY), ignoring cropping parameters. */
1718                 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
1719                         mutex_unlock(&btv->lock);
1720                         return -EINVAL;
1721                 }
1722
1723                 mutex_unlock(&btv->lock);
1724
1725                 c.rect = bttv_tvnorms[norm].cropcap.defrect;
1726         } else {
1727                 mutex_lock(&btv->lock);
1728
1729                 norm = btv->tvnorm;
1730                 c = btv->crop[!!fh->do_crop];
1731
1732                 mutex_unlock(&btv->lock);
1733
1734                 if (width < c.min_scaled_width ||
1735                     width > c.max_scaled_width ||
1736                     height < c.min_scaled_height)
1737                         return -EINVAL;
1738
1739                 switch (field) {
1740                 case V4L2_FIELD_TOP:
1741                 case V4L2_FIELD_BOTTOM:
1742                 case V4L2_FIELD_ALTERNATE:
1743                         /* btv->crop counts frame lines. Max. scale
1744                            factor is 16:1 for frames, 8:1 for fields. */
1745                         if (height * 2 > c.max_scaled_height)
1746                                 return -EINVAL;
1747                         break;
1748
1749                 default:
1750                         if (height > c.max_scaled_height)
1751                                 return -EINVAL;
1752                         break;
1753                 }
1754
1755                 buf->vb.size = (width * height * fmt->depth) >> 3;
1756                 if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
1757                         return -EINVAL;
1758         }
1759
1760         /* alloc + fill struct bttv_buffer (if changed) */
1761         if (buf->vb.width != width || buf->vb.height != height ||
1762             buf->vb.field != field ||
1763             buf->tvnorm != norm || buf->fmt != fmt ||
1764             buf->crop.top != c.rect.top ||
1765             buf->crop.left != c.rect.left ||
1766             buf->crop.width != c.rect.width ||
1767             buf->crop.height != c.rect.height) {
1768                 buf->vb.width  = width;
1769                 buf->vb.height = height;
1770                 buf->vb.field  = field;
1771                 buf->tvnorm    = norm;
1772                 buf->fmt       = fmt;
1773                 buf->crop      = c.rect;
1774                 redo_dma_risc = 1;
1775         }
1776
1777         /* alloc risc memory */
1778         if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1779                 redo_dma_risc = 1;
1780                 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
1781                         goto fail;
1782         }
1783
1784         if (redo_dma_risc)
1785                 if (0 != (rc = bttv_buffer_risc(btv,buf)))
1786                         goto fail;
1787
1788         buf->vb.state = VIDEOBUF_PREPARED;
1789         return 0;
1790
1791  fail:
1792         bttv_dma_free(q,btv,buf);
1793         return rc;
1794 }
1795
1796 static int
1797 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1798 {
1799         struct bttv_fh *fh = q->priv_data;
1800
1801         *size = fh->fmt->depth*fh->width*fh->height >> 3;
1802         if (0 == *count)
1803                 *count = gbuffers;
1804         while (*size * *count > gbuffers * gbufsize)
1805                 (*count)--;
1806         return 0;
1807 }
1808
1809 static int
1810 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1811                enum v4l2_field field)
1812 {
1813         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1814         struct bttv_fh *fh = q->priv_data;
1815
1816         return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
1817                                    fh->width, fh->height, field);
1818 }
1819
1820 static void
1821 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1822 {
1823         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1824         struct bttv_fh *fh = q->priv_data;
1825         struct bttv    *btv = fh->btv;
1826
1827         buf->vb.state = VIDEOBUF_QUEUED;
1828         list_add_tail(&buf->vb.queue,&btv->capture);
1829         if (!btv->curr.frame_irq) {
1830                 btv->loop_irq |= 1;
1831                 bttv_set_dma(btv, 0x03);
1832         }
1833 }
1834
1835 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1836 {
1837         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1838         struct bttv_fh *fh = q->priv_data;
1839
1840         bttv_dma_free(q,fh->btv,buf);
1841 }
1842
1843 static struct videobuf_queue_ops bttv_video_qops = {
1844         .buf_setup    = buffer_setup,
1845         .buf_prepare  = buffer_prepare,
1846         .buf_queue    = buffer_queue,
1847         .buf_release  = buffer_release,
1848 };
1849
1850 static int bttv_s_std(struct file *file, void *priv, v4l2_std_id *id)
1851 {
1852         struct bttv_fh *fh  = priv;
1853         struct bttv *btv = fh->btv;
1854         unsigned int i;
1855         int err;
1856
1857         err = v4l2_prio_check(&btv->prio, &fh->prio);
1858         if (0 != err)
1859                 return err;
1860
1861         for (i = 0; i < BTTV_TVNORMS; i++)
1862                 if (*id & bttv_tvnorms[i].v4l2_id)
1863                         break;
1864         if (i == BTTV_TVNORMS)
1865                 return -EINVAL;
1866
1867         mutex_lock(&btv->lock);
1868         set_tvnorm(btv, i);
1869         mutex_unlock(&btv->lock);
1870
1871         return 0;
1872 }
1873
1874 static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id)
1875 {
1876         struct bttv_fh *fh = f;
1877         struct bttv *btv = fh->btv;
1878
1879         if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1880                 *id = V4L2_STD_625_50;
1881         else
1882                 *id = V4L2_STD_525_60;
1883         return 0;
1884 }
1885
1886 static int bttv_enum_input(struct file *file, void *priv,
1887                                         struct v4l2_input *i)
1888 {
1889         struct bttv_fh *fh = priv;
1890         struct bttv *btv = fh->btv;
1891         unsigned int n;
1892
1893         n = i->index;
1894
1895         if (n >= bttv_tvcards[btv->c.type].video_inputs)
1896                 return -EINVAL;
1897
1898         memset(i, 0, sizeof(*i));
1899
1900         i->index    = n;
1901         i->type     = V4L2_INPUT_TYPE_CAMERA;
1902         i->audioset = 1;
1903
1904         if (i->index == bttv_tvcards[btv->c.type].tuner) {
1905                 sprintf(i->name, "Television");
1906                 i->type  = V4L2_INPUT_TYPE_TUNER;
1907                 i->tuner = 0;
1908         } else if (i->index == btv->svhs) {
1909                 sprintf(i->name, "S-Video");
1910         } else {
1911                 sprintf(i->name, "Composite%d", i->index);
1912         }
1913
1914         if (i->index == btv->input) {
1915                 __u32 dstatus = btread(BT848_DSTATUS);
1916                 if (0 == (dstatus & BT848_DSTATUS_PRES))
1917                         i->status |= V4L2_IN_ST_NO_SIGNAL;
1918                 if (0 == (dstatus & BT848_DSTATUS_HLOC))
1919                         i->status |= V4L2_IN_ST_NO_H_LOCK;
1920         }
1921
1922         for (n = 0; n < BTTV_TVNORMS; n++)
1923                 i->std |= bttv_tvnorms[n].v4l2_id;
1924
1925         return 0;
1926 }
1927
1928 static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
1929 {
1930         struct bttv_fh *fh = priv;
1931         struct bttv *btv = fh->btv;
1932
1933         *i = btv->input;
1934         return 0;
1935 }
1936
1937 static int bttv_s_input(struct file *file, void *priv, unsigned int i)
1938 {
1939         struct bttv_fh *fh  = priv;
1940         struct bttv *btv = fh->btv;
1941
1942         int err;
1943
1944         err = v4l2_prio_check(&btv->prio, &fh->prio);
1945         if (0 != err)
1946                 return err;
1947
1948         if (i > bttv_tvcards[btv->c.type].video_inputs)
1949                 return -EINVAL;
1950
1951         mutex_lock(&btv->lock);
1952         set_input(btv, i, btv->tvnorm);
1953         mutex_unlock(&btv->lock);
1954         return 0;
1955 }
1956
1957 static int bttv_s_tuner(struct file *file, void *priv,
1958                                         struct v4l2_tuner *t)
1959 {
1960         struct bttv_fh *fh  = priv;
1961         struct bttv *btv = fh->btv;
1962         int err;
1963
1964         err = v4l2_prio_check(&btv->prio, &fh->prio);
1965         if (0 != err)
1966                 return err;
1967
1968         if (UNSET == bttv_tvcards[btv->c.type].tuner)
1969                 return -EINVAL;
1970
1971         if (0 != t->index)
1972                 return -EINVAL;
1973
1974         mutex_lock(&btv->lock);
1975         bttv_call_i2c_clients(btv, VIDIOC_S_TUNER, t);
1976
1977         if (btv->audio_mode_gpio)
1978                 btv->audio_mode_gpio(btv, t, 1);
1979
1980         mutex_unlock(&btv->lock);
1981
1982         return 0;
1983 }
1984
1985 static int bttv_g_frequency(struct file *file, void *priv,
1986                                         struct v4l2_frequency *f)
1987 {
1988         struct bttv_fh *fh  = priv;
1989         struct bttv *btv = fh->btv;
1990         int err;
1991
1992         err = v4l2_prio_check(&btv->prio, &fh->prio);
1993         if (0 != err)
1994                 return err;
1995
1996         f->type = btv->radio_user ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1997         f->frequency = btv->freq;
1998
1999         return 0;
2000 }
2001
2002 static int bttv_s_frequency(struct file *file, void *priv,
2003                                         struct v4l2_frequency *f)
2004 {
2005         struct bttv_fh *fh  = priv;
2006         struct bttv *btv = fh->btv;
2007         int err;
2008
2009         err = v4l2_prio_check(&btv->prio, &fh->prio);
2010         if (0 != err)
2011                 return err;
2012
2013         if (unlikely(f->tuner != 0))
2014                 return -EINVAL;
2015         if (unlikely(f->type != (btv->radio_user
2016                 ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV)))
2017                 return -EINVAL;
2018         mutex_lock(&btv->lock);
2019         btv->freq = f->frequency;
2020         bttv_call_i2c_clients(btv, VIDIOC_S_FREQUENCY, f);
2021         if (btv->has_matchbox && btv->radio_user)
2022                 tea5757_set_freq(btv, btv->freq);
2023         mutex_unlock(&btv->lock);
2024         return 0;
2025 }
2026
2027 static int bttv_log_status(struct file *file, void *f)
2028 {
2029         struct bttv_fh *fh  = f;
2030         struct bttv *btv = fh->btv;
2031
2032         printk(KERN_INFO "bttv%d: ========  START STATUS CARD #%d  ========\n",
2033                         btv->c.nr, btv->c.nr);
2034         bttv_call_i2c_clients(btv, VIDIOC_LOG_STATUS, NULL);
2035         printk(KERN_INFO "bttv%d: ========  END STATUS CARD   #%d  ========\n",
2036                         btv->c.nr, btv->c.nr);
2037         return 0;
2038 }
2039
2040 #ifdef CONFIG_VIDEO_ADV_DEBUG
2041 static int bttv_g_register(struct file *file, void *f,
2042                                         struct v4l2_dbg_register *reg)
2043 {
2044         struct bttv_fh *fh = f;
2045         struct bttv *btv = fh->btv;
2046
2047         if (!capable(CAP_SYS_ADMIN))
2048                 return -EPERM;
2049
2050         if (!v4l2_chip_match_host(&reg->match))
2051                 return -EINVAL;
2052
2053         /* bt848 has a 12-bit register space */
2054         reg->reg &= 0xfff;
2055         reg->val = btread(reg->reg);
2056         reg->size = 1;
2057
2058         return 0;
2059 }
2060
2061 static int bttv_s_register(struct file *file, void *f,
2062                                         struct v4l2_dbg_register *reg)
2063 {
2064         struct bttv_fh *fh = f;
2065         struct bttv *btv = fh->btv;
2066
2067         if (!capable(CAP_SYS_ADMIN))
2068                 return -EPERM;
2069
2070         if (!v4l2_chip_match_host(&reg->match))
2071                 return -EINVAL;
2072
2073         /* bt848 has a 12-bit register space */
2074         reg->reg &= 0xfff;
2075         btwrite(reg->val, reg->reg);
2076
2077         return 0;
2078 }
2079 #endif
2080
2081 /* Given cropping boundaries b and the scaled width and height of a
2082    single field or frame, which must not exceed hardware limits, this
2083    function adjusts the cropping parameters c. */
2084 static void
2085 bttv_crop_adjust        (struct bttv_crop *             c,
2086                          const struct v4l2_rect *       b,
2087                          __s32                          width,
2088                          __s32                          height,
2089                          enum v4l2_field                field)
2090 {
2091         __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
2092         __s32 max_left;
2093         __s32 max_top;
2094
2095         if (width < c->min_scaled_width) {
2096                 /* Max. hor. scale factor 16:1. */
2097                 c->rect.width = width * 16;
2098         } else if (width > c->max_scaled_width) {
2099                 /* Min. hor. scale factor 1:1. */
2100                 c->rect.width = width;
2101
2102                 max_left = b->left + b->width - width;
2103                 max_left = min(max_left, (__s32) MAX_HDELAY);
2104                 if (c->rect.left > max_left)
2105                         c->rect.left = max_left;
2106         }
2107
2108         if (height < c->min_scaled_height) {
2109                 /* Max. vert. scale factor 16:1, single fields 8:1. */
2110                 c->rect.height = height * 16;
2111         } else if (frame_height > c->max_scaled_height) {
2112                 /* Min. vert. scale factor 1:1.
2113                    Top and height count field lines times two. */
2114                 c->rect.height = (frame_height + 1) & ~1;
2115
2116                 max_top = b->top + b->height - c->rect.height;
2117                 if (c->rect.top > max_top)
2118                         c->rect.top = max_top;
2119         }
2120
2121         bttv_crop_calc_limits(c);
2122 }
2123
2124 /* Returns an error if scaling to a frame or single field with the given
2125    width and height is not possible with the current cropping parameters
2126    and width aligned according to width_mask. If adjust_size is TRUE the
2127    function may adjust the width and/or height instead, rounding width
2128    to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
2129    also adjust the current cropping parameters to get closer to the
2130    desired image size. */
2131 static int
2132 limit_scaled_size       (struct bttv_fh *               fh,
2133                          __s32 *                        width,
2134                          __s32 *                        height,
2135                          enum v4l2_field                field,
2136                          unsigned int                   width_mask,
2137                          unsigned int                   width_bias,
2138                          int                            adjust_size,
2139                          int                            adjust_crop)
2140 {
2141         struct bttv *btv = fh->btv;
2142         const struct v4l2_rect *b;
2143         struct bttv_crop *c;
2144         __s32 min_width;
2145         __s32 min_height;
2146         __s32 max_width;
2147         __s32 max_height;
2148         int rc;
2149
2150         BUG_ON((int) width_mask >= 0 ||
2151                width_bias >= (unsigned int) -width_mask);
2152
2153         /* Make sure tvnorm, vbi_end and the current cropping parameters
2154            remain consistent until we're done. */
2155         mutex_lock(&btv->lock);
2156
2157         b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2158
2159         /* Do crop - use current, don't - use default parameters. */
2160         c = &btv->crop[!!fh->do_crop];
2161
2162         if (fh->do_crop
2163             && adjust_size
2164             && adjust_crop
2165             && !locked_btres(btv, VIDEO_RESOURCES)) {
2166                 min_width = 48;
2167                 min_height = 32;
2168
2169                 /* We cannot scale up. When the scaled image is larger
2170                    than crop.rect we adjust the crop.rect as required
2171                    by the V4L2 spec, hence cropcap.bounds are our limit. */
2172                 max_width = min(b->width, (__s32) MAX_HACTIVE);
2173                 max_height = b->height;
2174
2175                 /* We cannot capture the same line as video and VBI data.
2176                    Note btv->vbi_end is really a minimum, see
2177                    bttv_vbi_try_fmt(). */
2178                 if (btv->vbi_end > b->top) {
2179                         max_height -= btv->vbi_end - b->top;
2180                         rc = -EBUSY;
2181                         if (min_height > max_height)
2182                                 goto fail;
2183                 }
2184         } else {
2185                 rc = -EBUSY;
2186                 if (btv->vbi_end > c->rect.top)
2187                         goto fail;
2188
2189                 min_width  = c->min_scaled_width;
2190                 min_height = c->min_scaled_height;
2191                 max_width  = c->max_scaled_width;
2192                 max_height = c->max_scaled_height;
2193
2194                 adjust_crop = 0;
2195         }
2196
2197         min_width = (min_width - width_mask - 1) & width_mask;
2198         max_width = max_width & width_mask;
2199
2200         /* Max. scale factor is 16:1 for frames, 8:1 for fields. */
2201         min_height = min_height;
2202         /* Min. scale factor is 1:1. */
2203         max_height >>= !V4L2_FIELD_HAS_BOTH(field);
2204
2205         if (adjust_size) {
2206                 *width = clamp(*width, min_width, max_width);
2207                 *height = clamp(*height, min_height, max_height);
2208
2209                 /* Round after clamping to avoid overflow. */
2210                 *width = (*width + width_bias) & width_mask;
2211
2212                 if (adjust_crop) {
2213                         bttv_crop_adjust(c, b, *width, *height, field);
2214
2215                         if (btv->vbi_end > c->rect.top) {
2216                                 /* Move the crop window out of the way. */
2217                                 c->rect.top = btv->vbi_end;
2218                         }
2219                 }
2220         } else {
2221                 rc = -EINVAL;
2222                 if (*width  < min_width ||
2223                     *height < min_height ||
2224                     *width  > max_width ||
2225                     *height > max_height ||
2226                     0 != (*width & ~width_mask))
2227                         goto fail;
2228         }
2229
2230         rc = 0; /* success */
2231
2232  fail:
2233         mutex_unlock(&btv->lock);
2234
2235         return rc;
2236 }
2237
2238 /* Returns an error if the given overlay window dimensions are not
2239    possible with the current cropping parameters. If adjust_size is
2240    TRUE the function may adjust the window width and/or height
2241    instead, however it always rounds the horizontal position and
2242    width as btcx_align() does. If adjust_crop is TRUE the function
2243    may also adjust the current cropping parameters to get closer
2244    to the desired window size. */
2245 static int
2246 verify_window           (struct bttv_fh *               fh,
2247                          struct v4l2_window *           win,
2248                          int                            adjust_size,
2249                          int                            adjust_crop)
2250 {
2251         enum v4l2_field field;
2252         unsigned int width_mask;
2253         int rc;
2254
2255         if (win->w.width  < 48 || win->w.height < 32)
2256                 return -EINVAL;
2257         if (win->clipcount > 2048)
2258                 return -EINVAL;
2259
2260         field = win->field;
2261
2262         if (V4L2_FIELD_ANY == field) {
2263                 __s32 height2;
2264
2265                 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2266                 field = (win->w.height > height2)
2267                         ? V4L2_FIELD_INTERLACED
2268                         : V4L2_FIELD_TOP;
2269         }
2270         switch (field) {
2271         case V4L2_FIELD_TOP:
2272         case V4L2_FIELD_BOTTOM:
2273         case V4L2_FIELD_INTERLACED:
2274                 break;
2275         default:
2276                 return -EINVAL;
2277         }
2278
2279         /* 4-byte alignment. */
2280         if (NULL == fh->ovfmt)
2281                 return -EINVAL;
2282         width_mask = ~0;
2283         switch (fh->ovfmt->depth) {
2284         case 8:
2285         case 24:
2286                 width_mask = ~3;
2287                 break;
2288         case 16:
2289                 width_mask = ~1;
2290                 break;
2291         case 32:
2292                 break;
2293         default:
2294                 BUG();
2295         }
2296
2297         win->w.width -= win->w.left & ~width_mask;
2298         win->w.left = (win->w.left - width_mask - 1) & width_mask;
2299
2300         rc = limit_scaled_size(fh, &win->w.width, &win->w.height,
2301                                field, width_mask,
2302                                /* width_bias: round down */ 0,
2303                                adjust_size, adjust_crop);
2304         if (0 != rc)
2305                 return rc;
2306
2307         win->field = field;
2308         return 0;
2309 }
2310
2311 static int setup_window(struct bttv_fh *fh, struct bttv *btv,
2312                         struct v4l2_window *win, int fixup)
2313 {
2314         struct v4l2_clip *clips = NULL;
2315         int n,size,retval = 0;
2316
2317         if (NULL == fh->ovfmt)
2318                 return -EINVAL;
2319         if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2320                 return -EINVAL;
2321         retval = verify_window(fh, win,
2322                                /* adjust_size */ fixup,
2323                                /* adjust_crop */ fixup);
2324         if (0 != retval)
2325                 return retval;
2326
2327         /* copy clips  --  luckily v4l1 + v4l2 are binary
2328            compatible here ...*/
2329         n = win->clipcount;
2330         size = sizeof(*clips)*(n+4);
2331         clips = kmalloc(size,GFP_KERNEL);
2332         if (NULL == clips)
2333                 return -ENOMEM;
2334         if (n > 0) {
2335                 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2336                         kfree(clips);
2337                         return -EFAULT;
2338                 }
2339         }
2340         /* clip against screen */
2341         if (NULL != btv->fbuf.base)
2342                 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2343                                       &win->w, clips, n);
2344         btcx_sort_clips(clips,n);
2345
2346         /* 4-byte alignments */
2347         switch (fh->ovfmt->depth) {
2348         case 8:
2349         case 24:
2350                 btcx_align(&win->w, clips, n, 3);
2351                 break;
2352         case 16:
2353                 btcx_align(&win->w, clips, n, 1);
2354                 break;
2355         case 32:
2356                 /* no alignment fixups needed */
2357                 break;
2358         default:
2359                 BUG();
2360         }
2361
2362         mutex_lock(&fh->cap.vb_lock);
2363         kfree(fh->ov.clips);
2364         fh->ov.clips    = clips;
2365         fh->ov.nclips   = n;
2366
2367         fh->ov.w        = win->w;
2368         fh->ov.field    = win->field;
2369         fh->ov.setup_ok = 1;
2370         btv->init.ov.w.width   = win->w.width;
2371         btv->init.ov.w.height  = win->w.height;
2372         btv->init.ov.field     = win->field;
2373
2374         /* update overlay if needed */
2375         retval = 0;
2376         if (check_btres(fh, RESOURCE_OVERLAY)) {
2377                 struct bttv_buffer *new;
2378
2379                 new = videobuf_sg_alloc(sizeof(*new));
2380                 new->crop = btv->crop[!!fh->do_crop].rect;
2381                 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2382                 retval = bttv_switch_overlay(btv,fh,new);
2383         }
2384         mutex_unlock(&fh->cap.vb_lock);
2385         return retval;
2386 }
2387
2388 /* ----------------------------------------------------------------------- */
2389
2390 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2391 {
2392         struct videobuf_queue* q = NULL;
2393
2394         switch (fh->type) {
2395         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2396                 q = &fh->cap;
2397                 break;
2398         case V4L2_BUF_TYPE_VBI_CAPTURE:
2399                 q = &fh->vbi;
2400                 break;
2401         default:
2402                 BUG();
2403         }
2404         return q;
2405 }
2406
2407 static int bttv_resource(struct bttv_fh *fh)
2408 {
2409         int res = 0;
2410
2411         switch (fh->type) {
2412         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2413                 res = RESOURCE_VIDEO_STREAM;
2414                 break;
2415         case V4L2_BUF_TYPE_VBI_CAPTURE:
2416                 res = RESOURCE_VBI;
2417                 break;
2418         default:
2419                 BUG();
2420         }
2421         return res;
2422 }
2423
2424 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2425 {
2426         struct videobuf_queue *q = bttv_queue(fh);
2427         int res = bttv_resource(fh);
2428
2429         if (check_btres(fh,res))
2430                 return -EBUSY;
2431         if (videobuf_queue_is_busy(q))
2432                 return -EBUSY;
2433         fh->type = type;
2434         return 0;
2435 }
2436
2437 static void
2438 pix_format_set_size     (struct v4l2_pix_format *       f,
2439                          const struct bttv_format *     fmt,
2440                          unsigned int                   width,
2441                          unsigned int                   height)
2442 {
2443         f->width = width;
2444         f->height = height;
2445
2446         if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2447                 f->bytesperline = width; /* Y plane */
2448                 f->sizeimage = (width * height * fmt->depth) >> 3;
2449         } else {
2450                 f->bytesperline = (width * fmt->depth) >> 3;
2451                 f->sizeimage = height * f->bytesperline;
2452         }
2453 }
2454
2455 static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
2456                                         struct v4l2_format *f)
2457 {
2458         struct bttv_fh *fh  = priv;
2459
2460         pix_format_set_size(&f->fmt.pix, fh->fmt,
2461                                 fh->width, fh->height);
2462         f->fmt.pix.field        = fh->cap.field;
2463         f->fmt.pix.pixelformat  = fh->fmt->fourcc;
2464
2465         return 0;
2466 }
2467
2468 static int bttv_g_fmt_vid_overlay(struct file *file, void *priv,
2469                                         struct v4l2_format *f)
2470 {
2471         struct bttv_fh *fh  = priv;
2472
2473         f->fmt.win.w     = fh->ov.w;
2474         f->fmt.win.field = fh->ov.field;
2475
2476         return 0;
2477 }
2478
2479 static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
2480                                                 struct v4l2_format *f)
2481 {
2482         const struct bttv_format *fmt;
2483         struct bttv_fh *fh = priv;
2484         struct bttv *btv = fh->btv;
2485         enum v4l2_field field;
2486         __s32 width, height;
2487         int rc;
2488
2489         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2490         if (NULL == fmt)
2491                 return -EINVAL;
2492
2493         field = f->fmt.pix.field;
2494
2495         if (V4L2_FIELD_ANY == field) {
2496                 __s32 height2;
2497
2498                 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2499                 field = (f->fmt.pix.height > height2)
2500                         ? V4L2_FIELD_INTERLACED
2501                         : V4L2_FIELD_BOTTOM;
2502         }
2503
2504         if (V4L2_FIELD_SEQ_BT == field)
2505                 field = V4L2_FIELD_SEQ_TB;
2506
2507         switch (field) {
2508         case V4L2_FIELD_TOP:
2509         case V4L2_FIELD_BOTTOM:
2510         case V4L2_FIELD_ALTERNATE:
2511         case V4L2_FIELD_INTERLACED:
2512                 break;
2513         case V4L2_FIELD_SEQ_TB:
2514                 if (fmt->flags & FORMAT_FLAGS_PLANAR)
2515                         return -EINVAL;
2516                 break;
2517         default:
2518                 return -EINVAL;
2519         }
2520
2521         width = f->fmt.pix.width;
2522         height = f->fmt.pix.height;
2523
2524         rc = limit_scaled_size(fh, &width, &height, field,
2525                                /* width_mask: 4 pixels */ ~3,
2526                                /* width_bias: nearest */ 2,
2527                                /* adjust_size */ 1,
2528                                /* adjust_crop */ 0);
2529         if (0 != rc)
2530                 return rc;
2531
2532         /* update data for the application */
2533         f->fmt.pix.field = field;
2534         pix_format_set_size(&f->fmt.pix, fmt, width, height);
2535
2536         return 0;
2537 }
2538
2539 static int bttv_try_fmt_vid_overlay(struct file *file, void *priv,
2540                                                 struct v4l2_format *f)
2541 {
2542         struct bttv_fh *fh = priv;
2543
2544         return verify_window(fh, &f->fmt.win,
2545                         /* adjust_size */ 1,
2546                         /* adjust_crop */ 0);
2547 }
2548
2549 static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2550                                 struct v4l2_format *f)
2551 {
2552         int retval;
2553         const struct bttv_format *fmt;
2554         struct bttv_fh *fh = priv;
2555         struct bttv *btv = fh->btv;
2556         __s32 width, height;
2557         enum v4l2_field field;
2558
2559         retval = bttv_switch_type(fh, f->type);
2560         if (0 != retval)
2561                 return retval;
2562
2563         retval = bttv_try_fmt_vid_cap(file, priv, f);
2564         if (0 != retval)
2565                 return retval;
2566
2567         width = f->fmt.pix.width;
2568         height = f->fmt.pix.height;
2569         field = f->fmt.pix.field;
2570
2571         retval = limit_scaled_size(fh, &width, &height, f->fmt.pix.field,
2572                                /* width_mask: 4 pixels */ ~3,
2573                                /* width_bias: nearest */ 2,
2574                                /* adjust_size */ 1,
2575                                /* adjust_crop */ 1);
2576         if (0 != retval)
2577                 return retval;
2578
2579         f->fmt.pix.field = field;
2580
2581         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2582
2583         /* update our state informations */
2584         mutex_lock(&fh->cap.vb_lock);
2585         fh->fmt              = fmt;
2586         fh->cap.field        = f->fmt.pix.field;
2587         fh->cap.last         = V4L2_FIELD_NONE;
2588         fh->width            = f->fmt.pix.width;
2589         fh->height           = f->fmt.pix.height;
2590         btv->init.fmt        = fmt;
2591         btv->init.width      = f->fmt.pix.width;
2592         btv->init.height     = f->fmt.pix.height;
2593         mutex_unlock(&fh->cap.vb_lock);
2594
2595         return 0;
2596 }
2597
2598 static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
2599                                 struct v4l2_format *f)
2600 {
2601         struct bttv_fh *fh = priv;
2602         struct bttv *btv = fh->btv;
2603
2604         if (no_overlay > 0) {
2605                 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2606                 return -EINVAL;
2607         }
2608
2609         return setup_window(fh, btv, &f->fmt.win, 1);
2610 }
2611
2612 #ifdef CONFIG_VIDEO_V4L1_COMPAT
2613 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
2614 {
2615         int retval;
2616         unsigned int i;
2617         struct bttv_fh *fh = priv;
2618
2619         mutex_lock(&fh->cap.vb_lock);
2620         retval = __videobuf_mmap_setup(&fh->cap, gbuffers, gbufsize,
2621                                      V4L2_MEMORY_MMAP);
2622         if (retval < 0) {
2623                 mutex_unlock(&fh->cap.vb_lock);
2624                 return retval;
2625         }
2626
2627         gbuffers = retval;
2628         memset(mbuf, 0, sizeof(*mbuf));
2629         mbuf->frames = gbuffers;
2630         mbuf->size   = gbuffers * gbufsize;
2631
2632         for (i = 0; i < gbuffers; i++)
2633                 mbuf->offsets[i] = i * gbufsize;
2634
2635         mutex_unlock(&fh->cap.vb_lock);
2636         return 0;
2637 }
2638 #endif
2639
2640 static int bttv_querycap(struct file *file, void  *priv,
2641                                 struct v4l2_capability *cap)
2642 {
2643         struct bttv_fh *fh = priv;
2644         struct bttv *btv = fh->btv;
2645
2646         if (0 == v4l2)
2647                 return -EINVAL;
2648
2649         strlcpy(cap->driver, "bttv", sizeof(cap->driver));
2650         strlcpy(cap->card, btv->video_dev->name, sizeof(cap->card));
2651         snprintf(cap->bus_info, sizeof(cap->bus_info),
2652                  "PCI:%s", pci_name(btv->c.pci));
2653         cap->version = BTTV_VERSION_CODE;
2654         cap->capabilities =
2655                 V4L2_CAP_VIDEO_CAPTURE |
2656                 V4L2_CAP_VBI_CAPTURE |
2657                 V4L2_CAP_READWRITE |
2658                 V4L2_CAP_STREAMING;
2659         if (no_overlay <= 0)
2660                 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2661
2662         if (bttv_tvcards[btv->c.type].tuner != UNSET &&
2663             bttv_tvcards[btv->c.type].tuner != TUNER_ABSENT)
2664                 cap->capabilities |= V4L2_CAP_TUNER;
2665         return 0;
2666 }
2667
2668 static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f)
2669 {
2670         int index = -1, i;
2671
2672         for (i = 0; i < FORMATS; i++) {
2673                 if (formats[i].fourcc != -1)
2674                         index++;
2675                 if ((unsigned int)index == f->index)
2676                         break;
2677         }
2678         if (FORMATS == i)
2679                 return -EINVAL;
2680
2681         f->pixelformat = formats[i].fourcc;
2682         strlcpy(f->description, formats[i].name, sizeof(f->description));
2683
2684         return i;
2685 }
2686
2687 static int bttv_enum_fmt_vid_cap(struct file *file, void  *priv,
2688                                 struct v4l2_fmtdesc *f)
2689 {
2690         int rc = bttv_enum_fmt_cap_ovr(f);
2691
2692         if (rc < 0)
2693                 return rc;
2694
2695         return 0;
2696 }
2697
2698 static int bttv_enum_fmt_vid_overlay(struct file *file, void  *priv,
2699                                         struct v4l2_fmtdesc *f)
2700 {
2701         int rc;
2702
2703         if (no_overlay > 0) {
2704                 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2705                 return -EINVAL;
2706         }
2707
2708         rc = bttv_enum_fmt_cap_ovr(f);
2709
2710         if (rc < 0)
2711                 return rc;
2712
2713         if (!(formats[rc].flags & FORMAT_FLAGS_PACKED))
2714                 return -EINVAL;
2715
2716         return 0;
2717 }
2718
2719 static int bttv_g_fbuf(struct file *file, void *f,
2720                                 struct v4l2_framebuffer *fb)
2721 {
2722         struct bttv_fh *fh = f;
2723         struct bttv *btv = fh->btv;
2724
2725         *fb = btv->fbuf;
2726         fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2727         if (fh->ovfmt)
2728                 fb->fmt.pixelformat  = fh->ovfmt->fourcc;
2729         return 0;
2730 }
2731
2732 static int bttv_overlay(struct file *file, void *f, unsigned int on)
2733 {
2734         struct bttv_fh *fh = f;
2735         struct bttv *btv = fh->btv;
2736         struct bttv_buffer *new;
2737         int retval;
2738
2739         if (on) {
2740                 /* verify args */
2741                 if (NULL == btv->fbuf.base)
2742                         return -EINVAL;
2743                 if (!fh->ov.setup_ok) {
2744                         dprintk("bttv%d: overlay: !setup_ok\n", btv->c.nr);
2745                         return -EINVAL;
2746                 }
2747         }
2748
2749         if (!check_alloc_btres(btv, fh, RESOURCE_OVERLAY))
2750                 return -EBUSY;
2751
2752         mutex_lock(&fh->cap.vb_lock);
2753         if (on) {
2754                 fh->ov.tvnorm = btv->tvnorm;
2755                 new = videobuf_sg_alloc(sizeof(*new));
2756                 new->crop = btv->crop[!!fh->do_crop].rect;
2757                 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2758         } else {
2759                 new = NULL;
2760         }
2761
2762         /* switch over */
2763         retval = bttv_switch_overlay(btv, fh, new);
2764         mutex_unlock(&fh->cap.vb_lock);
2765         return retval;
2766 }
2767
2768 static int bttv_s_fbuf(struct file *file, void *f,
2769                                 struct v4l2_framebuffer *fb)
2770 {
2771         struct bttv_fh *fh = f;
2772         struct bttv *btv = fh->btv;
2773         const struct bttv_format *fmt;
2774         int retval;
2775
2776         if (!capable(CAP_SYS_ADMIN) &&
2777                 !capable(CAP_SYS_RAWIO))
2778                 return -EPERM;
2779
2780         /* check args */
2781         fmt = format_by_fourcc(fb->fmt.pixelformat);
2782         if (NULL == fmt)
2783                 return -EINVAL;
2784         if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2785                 return -EINVAL;
2786
2787         retval = -EINVAL;
2788         if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2789                 __s32 width = fb->fmt.width;
2790                 __s32 height = fb->fmt.height;
2791
2792                 retval = limit_scaled_size(fh, &width, &height,
2793                                            V4L2_FIELD_INTERLACED,
2794                                            /* width_mask */ ~3,
2795                                            /* width_bias */ 2,
2796                                            /* adjust_size */ 0,
2797                                            /* adjust_crop */ 0);
2798                 if (0 != retval)
2799                         return retval;
2800         }
2801
2802         /* ok, accept it */
2803         mutex_lock(&fh->cap.vb_lock);
2804         btv->fbuf.base       = fb->base;
2805         btv->fbuf.fmt.width  = fb->fmt.width;
2806         btv->fbuf.fmt.height = fb->fmt.height;
2807         if (0 != fb->fmt.bytesperline)
2808                 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2809         else
2810                 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2811
2812         retval = 0;
2813         fh->ovfmt = fmt;
2814         btv->init.ovfmt = fmt;
2815         if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2816                 fh->ov.w.left   = 0;
2817                 fh->ov.w.top    = 0;
2818                 fh->ov.w.width  = fb->fmt.width;
2819                 fh->ov.w.height = fb->fmt.height;
2820                 btv->init.ov.w.width  = fb->fmt.width;
2821                 btv->init.ov.w.height = fb->fmt.height;
2822                         kfree(fh->ov.clips);
2823                 fh->ov.clips = NULL;
2824                 fh->ov.nclips = 0;
2825
2826                 if (check_btres(fh, RESOURCE_OVERLAY)) {
2827                         struct bttv_buffer *new;
2828
2829                         new = videobuf_sg_alloc(sizeof(*new));
2830                         new->crop = btv->crop[!!fh->do_crop].rect;
2831                         bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2832                         retval = bttv_switch_overlay(btv, fh, new);
2833                 }
2834         }
2835         mutex_unlock(&fh->cap.vb_lock);
2836         return retval;
2837 }
2838
2839 static int bttv_reqbufs(struct file *file, void *priv,
2840                                 struct v4l2_requestbuffers *p)
2841 {
2842         struct bttv_fh *fh = priv;
2843         return videobuf_reqbufs(bttv_queue(fh), p);
2844 }
2845
2846 static int bttv_querybuf(struct file *file, void *priv,
2847                                 struct v4l2_buffer *b)
2848 {
2849         struct bttv_fh *fh = priv;
2850         return videobuf_querybuf(bttv_queue(fh), b);
2851 }
2852
2853 static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2854 {
2855         struct bttv_fh *fh = priv;
2856         struct bttv *btv = fh->btv;
2857         int res = bttv_resource(fh);
2858
2859         if (!check_alloc_btres(btv, fh, res))
2860                 return -EBUSY;
2861
2862         return videobuf_qbuf(bttv_queue(fh), b);
2863 }
2864
2865 static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2866 {
2867         struct bttv_fh *fh = priv;
2868         return videobuf_dqbuf(bttv_queue(fh), b,
2869                         file->f_flags & O_NONBLOCK);
2870 }
2871
2872 static int bttv_streamon(struct file *file, void *priv,
2873                                         enum v4l2_buf_type type)
2874 {
2875         struct bttv_fh *fh = priv;
2876         struct bttv *btv = fh->btv;
2877         int res = bttv_resource(fh);
2878
2879         if (!check_alloc_btres(btv, fh, res))
2880                 return -EBUSY;
2881         return videobuf_streamon(bttv_queue(fh));
2882 }
2883
2884
2885 static int bttv_streamoff(struct file *file, void *priv,
2886                                         enum v4l2_buf_type type)
2887 {
2888         struct bttv_fh *fh = priv;
2889         struct bttv *btv = fh->btv;
2890         int retval;
2891         int res = bttv_resource(fh);
2892
2893
2894         retval = videobuf_streamoff(bttv_queue(fh));
2895         if (retval < 0)
2896                 return retval;
2897         free_btres(btv, fh, res);
2898         return 0;
2899 }
2900
2901 static int bttv_queryctrl(struct file *file, void *priv,
2902                                         struct v4l2_queryctrl *c)
2903 {
2904         struct bttv_fh *fh = priv;
2905         struct bttv *btv = fh->btv;
2906         const struct v4l2_queryctrl *ctrl;
2907
2908         if ((c->id <  V4L2_CID_BASE ||
2909              c->id >= V4L2_CID_LASTP1) &&
2910             (c->id <  V4L2_CID_PRIVATE_BASE ||
2911              c->id >= V4L2_CID_PRIVATE_LASTP1))
2912                 return -EINVAL;
2913
2914         if (!btv->volume_gpio && (c->id == V4L2_CID_AUDIO_VOLUME))
2915                 *c = no_ctl;
2916         else {
2917                 ctrl = ctrl_by_id(c->id);
2918
2919                 *c = (NULL != ctrl) ? *ctrl : no_ctl;
2920         }
2921
2922         return 0;
2923 }
2924
2925 static int bttv_g_parm(struct file *file, void *f,
2926                                 struct v4l2_streamparm *parm)
2927 {
2928         struct bttv_fh *fh = f;
2929         struct bttv *btv = fh->btv;
2930         struct v4l2_standard s;
2931
2932         if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2933                 return -EINVAL;
2934         v4l2_video_std_construct(&s, bttv_tvnorms[btv->tvnorm].v4l2_id,
2935                                  bttv_tvnorms[btv->tvnorm].name);
2936         parm->parm.capture.timeperframe = s.frameperiod;
2937         return 0;
2938 }
2939
2940 static int bttv_g_tuner(struct file *file, void *priv,
2941                                 struct v4l2_tuner *t)
2942 {
2943         struct bttv_fh *fh = priv;
2944         struct bttv *btv = fh->btv;
2945
2946         if (UNSET == bttv_tvcards[btv->c.type].tuner)
2947                 return -EINVAL;
2948         if (0 != t->index)
2949                 return -EINVAL;
2950
2951         mutex_lock(&btv->lock);
2952         memset(t, 0, sizeof(*t));
2953         t->rxsubchans = V4L2_TUNER_SUB_MONO;
2954         bttv_call_i2c_clients(btv, VIDIOC_G_TUNER, t);
2955         strcpy(t->name, "Television");
2956         t->capability = V4L2_TUNER_CAP_NORM;
2957         t->type       = V4L2_TUNER_ANALOG_TV;
2958         if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2959                 t->signal = 0xffff;
2960
2961         if (btv->audio_mode_gpio)
2962                 btv->audio_mode_gpio(btv, t, 0);
2963
2964         mutex_unlock(&btv->lock);
2965         return 0;
2966 }
2967
2968 static int bttv_g_priority(struct file *file, void *f, enum v4l2_priority *p)
2969 {
2970         struct bttv_fh *fh = f;
2971         struct bttv *btv = fh->btv;
2972
2973         *p = v4l2_prio_max(&btv->prio);
2974
2975         return 0;
2976 }
2977
2978 static int bttv_s_priority(struct file *file, void *f,
2979                                         enum v4l2_priority prio)
2980 {
2981         struct bttv_fh *fh = f;
2982         struct bttv *btv = fh->btv;
2983
2984         return v4l2_prio_change(&btv->prio, &fh->prio, prio);
2985 }
2986
2987 static int bttv_cropcap(struct file *file, void *priv,
2988                                 struct v4l2_cropcap *cap)
2989 {
2990         struct bttv_fh *fh = priv;
2991         struct bttv *btv = fh->btv;
2992
2993         if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2994             cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2995                 return -EINVAL;
2996
2997         *cap = bttv_tvnorms[btv->tvnorm].cropcap;
2998
2999         return 0;
3000 }
3001
3002 static int bttv_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
3003 {
3004         struct bttv_fh *fh = f;
3005         struct bttv *btv = fh->btv;
3006
3007         if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3008             crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3009                 return -EINVAL;
3010
3011         /* No fh->do_crop = 1; because btv->crop[1] may be
3012            inconsistent with fh->width or fh->height and apps
3013            do not expect a change here. */
3014
3015         crop->c = btv->crop[!!fh->do_crop].rect;
3016
3017         return 0;
3018 }
3019
3020 static int bttv_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
3021 {
3022         struct bttv_fh *fh = f;
3023         struct bttv *btv = fh->btv;
3024         const struct v4l2_rect *b;
3025         int retval;
3026         struct bttv_crop c;
3027         __s32 b_left;
3028         __s32 b_top;
3029         __s32 b_right;
3030         __s32 b_bottom;
3031
3032         if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3033             crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3034                 return -EINVAL;
3035
3036         retval = v4l2_prio_check(&btv->prio, &fh->prio);
3037         if (0 != retval)
3038                 return retval;
3039
3040         /* Make sure tvnorm, vbi_end and the current cropping
3041            parameters remain consistent until we're done. Note
3042            read() may change vbi_end in check_alloc_btres(). */
3043         mutex_lock(&btv->lock);
3044
3045         retval = -EBUSY;
3046
3047         if (locked_btres(fh->btv, VIDEO_RESOURCES)) {
3048                 mutex_unlock(&btv->lock);
3049                 return retval;
3050         }
3051
3052         b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
3053
3054         b_left = b->left;
3055         b_right = b_left + b->width;
3056         b_bottom = b->top + b->height;
3057
3058         b_top = max(b->top, btv->vbi_end);
3059         if (b_top + 32 >= b_bottom) {
3060                 mutex_unlock(&btv->lock);
3061                 return retval;
3062         }
3063
3064         /* Min. scaled size 48 x 32. */
3065         c.rect.left = clamp(crop->c.left, b_left, b_right - 48);
3066         c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
3067
3068         c.rect.width = clamp(crop->c.width,
3069                              48, b_right - c.rect.left);
3070
3071         c.rect.top = clamp(crop->c.top, b_top, b_bottom - 32);
3072         /* Top and height must be a multiple of two. */
3073         c.rect.top = (c.rect.top + 1) & ~1;
3074
3075         c.rect.height = clamp(crop->c.height,
3076                               32, b_bottom - c.rect.top);
3077         c.rect.height = (c.rect.height + 1) & ~1;
3078
3079         bttv_crop_calc_limits(&c);
3080
3081         btv->crop[1] = c;
3082
3083         mutex_unlock(&btv->lock);
3084
3085         fh->do_crop = 1;
3086
3087         mutex_lock(&fh->cap.vb_lock);
3088
3089         if (fh->width < c.min_scaled_width) {
3090                 fh->width = c.min_scaled_width;
3091                 btv->init.width = c.min_scaled_width;
3092         } else if (fh->width > c.max_scaled_width) {
3093                 fh->width = c.max_scaled_width;
3094                 btv->init.width = c.max_scaled_width;
3095         }
3096
3097         if (fh->height < c.min_scaled_height) {
3098                 fh->height = c.min_scaled_height;
3099                 btv->init.height = c.min_scaled_height;
3100         } else if (fh->height > c.max_scaled_height) {
3101                 fh->height = c.max_scaled_height;
3102                 btv->init.height = c.max_scaled_height;
3103         }
3104
3105         mutex_unlock(&fh->cap.vb_lock);
3106
3107         return 0;
3108 }
3109
3110 static int bttv_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
3111 {
3112         if (unlikely(a->index))
3113                 return -EINVAL;
3114
3115         strcpy(a->name, "audio");
3116         return 0;
3117 }
3118
3119 static int bttv_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
3120 {
3121         if (unlikely(a->index))
3122                 return -EINVAL;
3123
3124         return 0;
3125 }
3126
3127 static ssize_t bttv_read(struct file *file, char __user *data,
3128                          size_t count, loff_t *ppos)
3129 {
3130         struct bttv_fh *fh = file->private_data;
3131         int retval = 0;
3132
3133         if (fh->btv->errors)
3134                 bttv_reinit_bt848(fh->btv);
3135         dprintk("bttv%d: read count=%d type=%s\n",
3136                 fh->btv->c.nr,(int)count,v4l2_type_names[fh->type]);
3137
3138         switch (fh->type) {
3139         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3140                 if (!check_alloc_btres(fh->btv, fh, RESOURCE_VIDEO_READ)) {
3141                         /* VIDEO_READ in use by another fh,
3142                            or VIDEO_STREAM by any fh. */
3143                         return -EBUSY;
3144                 }
3145                 retval = videobuf_read_one(&fh->cap, data, count, ppos,
3146                                            file->f_flags & O_NONBLOCK);
3147                 free_btres(fh->btv, fh, RESOURCE_VIDEO_READ);
3148                 break;
3149         case V4L2_BUF_TYPE_VBI_CAPTURE:
3150                 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3151                         return -EBUSY;
3152                 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
3153                                               file->f_flags & O_NONBLOCK);
3154                 break;
3155         default:
3156                 BUG();
3157         }
3158         return retval;
3159 }
3160
3161 static unsigned int bttv_poll(struct file *file, poll_table *wait)
3162 {
3163         struct bttv_fh *fh = file->private_data;
3164         struct bttv_buffer *buf;
3165         enum v4l2_field field;
3166
3167         if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
3168                 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3169                         return POLLERR;
3170                 return videobuf_poll_stream(file, &fh->vbi, wait);
3171         }
3172
3173         if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
3174                 /* streaming capture */
3175                 if (list_empty(&fh->cap.stream))
3176                         return POLLERR;
3177                 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
3178         } else {
3179                 /* read() capture */
3180                 mutex_lock(&fh->cap.vb_lock);
3181                 if (NULL == fh->cap.read_buf) {
3182                         /* need to capture a new frame */
3183                         if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
3184                                 goto err;
3185                         fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize);
3186                         if (NULL == fh->cap.read_buf)
3187                                 goto err;
3188                         fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
3189                         field = videobuf_next_field(&fh->cap);
3190                         if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
3191                                 kfree (fh->cap.read_buf);
3192                                 fh->cap.read_buf = NULL;
3193                                 goto err;
3194                         }
3195                         fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
3196                         fh->cap.read_off = 0;
3197                 }
3198                 mutex_unlock(&fh->cap.vb_lock);
3199                 buf = (struct bttv_buffer*)fh->cap.read_buf;
3200         }
3201
3202         poll_wait(file, &buf->vb.done, wait);
3203         if (buf->vb.state == VIDEOBUF_DONE ||
3204             buf->vb.state == VIDEOBUF_ERROR)
3205                 return POLLIN|POLLRDNORM;
3206         return 0;
3207 err:
3208         mutex_unlock(&fh->cap.vb_lock);
3209         return POLLERR;
3210 }
3211
3212 static int bttv_open(struct file *file)
3213 {
3214         int minor = video_devdata(file)->minor;
3215         struct bttv *btv = NULL;
3216         struct bttv_fh *fh;
3217         enum v4l2_buf_type type = 0;
3218         unsigned int i;
3219
3220         dprintk(KERN_DEBUG "bttv: open minor=%d\n",minor);
3221
3222         lock_kernel();
3223         for (i = 0; i < bttv_num; i++) {
3224                 if (bttvs[i].video_dev &&
3225                     bttvs[i].video_dev->minor == minor) {
3226                         btv = &bttvs[i];
3227                         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3228                         break;
3229                 }
3230                 if (bttvs[i].vbi_dev &&
3231                     bttvs[i].vbi_dev->minor == minor) {
3232                         btv = &bttvs[i];
3233                         type = V4L2_BUF_TYPE_VBI_CAPTURE;
3234                         break;
3235                 }
3236         }
3237         if (NULL == btv) {
3238                 unlock_kernel();
3239                 return -ENODEV;
3240         }
3241
3242         dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
3243                 btv->c.nr,v4l2_type_names[type]);
3244
3245         /* allocate per filehandle data */
3246         fh = kmalloc(sizeof(*fh),GFP_KERNEL);
3247         if (NULL == fh) {
3248                 unlock_kernel();
3249                 return -ENOMEM;
3250         }
3251         file->private_data = fh;
3252         *fh = btv->init;
3253         fh->type = type;
3254         fh->ov.setup_ok = 0;
3255         v4l2_prio_open(&btv->prio,&fh->prio);
3256
3257         videobuf_queue_sg_init(&fh->cap, &bttv_video_qops,
3258                             &btv->c.pci->dev, &btv->s_lock,
3259                             V4L2_BUF_TYPE_VIDEO_CAPTURE,
3260                             V4L2_FIELD_INTERLACED,
3261                             sizeof(struct bttv_buffer),
3262                             fh);
3263         videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops,
3264                             &btv->c.pci->dev, &btv->s_lock,
3265                             V4L2_BUF_TYPE_VBI_CAPTURE,
3266                             V4L2_FIELD_SEQ_TB,
3267                             sizeof(struct bttv_buffer),
3268                             fh);
3269         set_tvnorm(btv,btv->tvnorm);
3270         set_input(btv, btv->input, btv->tvnorm);
3271
3272         btv->users++;
3273
3274         /* The V4L2 spec requires one global set of cropping parameters
3275            which only change on request. These are stored in btv->crop[1].
3276            However for compatibility with V4L apps and cropping unaware
3277            V4L2 apps we now reset the cropping parameters as seen through
3278            this fh, which is to say VIDIOC_G_CROP and scaling limit checks
3279            will use btv->crop[0], the default cropping parameters for the
3280            current video standard, and VIDIOC_S_FMT will not implicitely
3281            change the cropping parameters until VIDIOC_S_CROP has been
3282            called. */
3283         fh->do_crop = !reset_crop; /* module parameter */
3284
3285         /* Likewise there should be one global set of VBI capture
3286            parameters, but for compatibility with V4L apps and earlier
3287            driver versions each fh has its own parameters. */
3288         bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3289
3290         bttv_field_count(btv);
3291         unlock_kernel();
3292         return 0;
3293 }
3294
3295 static int bttv_release(struct file *file)
3296 {
3297         struct bttv_fh *fh = file->private_data;
3298         struct bttv *btv = fh->btv;
3299
3300         /* turn off overlay */
3301         if (check_btres(fh, RESOURCE_OVERLAY))
3302                 bttv_switch_overlay(btv,fh,NULL);
3303
3304         /* stop video capture */
3305         if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
3306                 videobuf_streamoff(&fh->cap);
3307                 free_btres(btv,fh,RESOURCE_VIDEO_STREAM);
3308         }
3309         if (fh->cap.read_buf) {
3310                 buffer_release(&fh->cap,fh->cap.read_buf);
3311                 kfree(fh->cap.read_buf);
3312         }
3313         if (check_btres(fh, RESOURCE_VIDEO_READ)) {
3314                 free_btres(btv, fh, RESOURCE_VIDEO_READ);
3315         }
3316
3317         /* stop vbi capture */
3318         if (check_btres(fh, RESOURCE_VBI)) {
3319                 videobuf_stop(&fh->vbi);
3320                 free_btres(btv,fh,RESOURCE_VBI);
3321         }
3322
3323         /* free stuff */
3324         videobuf_mmap_free(&fh->cap);
3325         videobuf_mmap_free(&fh->vbi);
3326         v4l2_prio_close(&btv->prio,&fh->prio);
3327         file->private_data = NULL;
3328         kfree(fh);
3329
3330         btv->users--;
3331         bttv_field_count(btv);
3332
3333         if (!btv->users)
3334                 audio_mute(btv, 1);
3335
3336         return 0;
3337 }
3338
3339 static int
3340 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3341 {
3342         struct bttv_fh *fh = file->private_data;
3343
3344         dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3345                 fh->btv->c.nr, v4l2_type_names[fh->type],
3346                 vma->vm_start, vma->vm_end - vma->vm_start);
3347         return videobuf_mmap_mapper(bttv_queue(fh),vma);
3348 }
3349
3350 static const struct v4l2_file_operations bttv_fops =
3351 {
3352         .owner    = THIS_MODULE,
3353         .open     = bttv_open,
3354         .release  = bttv_release,
3355         .ioctl    = video_ioctl2,
3356         .read     = bttv_read,
3357         .mmap     = bttv_mmap,
3358         .poll     = bttv_poll,
3359 };
3360
3361 static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
3362         .vidioc_querycap                = bttv_querycap,
3363         .vidioc_enum_fmt_vid_cap        = bttv_enum_fmt_vid_cap,
3364         .vidioc_g_fmt_vid_cap           = bttv_g_fmt_vid_cap,
3365         .vidioc_try_fmt_vid_cap         = bttv_try_fmt_vid_cap,
3366         .vidioc_s_fmt_vid_cap           = bttv_s_fmt_vid_cap,
3367         .vidioc_enum_fmt_vid_overlay    = bttv_enum_fmt_vid_overlay,
3368         .vidioc_g_fmt_vid_overlay       = bttv_g_fmt_vid_overlay,
3369         .vidioc_try_fmt_vid_overlay     = bttv_try_fmt_vid_overlay,
3370         .vidioc_s_fmt_vid_overlay       = bttv_s_fmt_vid_overlay,
3371         .vidioc_g_fmt_vbi_cap           = bttv_g_fmt_vbi_cap,
3372         .vidioc_try_fmt_vbi_cap         = bttv_try_fmt_vbi_cap,
3373         .vidioc_s_fmt_vbi_cap           = bttv_s_fmt_vbi_cap,
3374         .vidioc_g_audio                 = bttv_g_audio,
3375         .vidioc_s_audio                 = bttv_s_audio,
3376         .vidioc_cropcap                 = bttv_cropcap,
3377         .vidioc_reqbufs                 = bttv_reqbufs,
3378         .vidioc_querybuf                = bttv_querybuf,
3379         .vidioc_qbuf                    = bttv_qbuf,
3380         .vidioc_dqbuf                   = bttv_dqbuf,
3381         .vidioc_s_std                   = bttv_s_std,
3382         .vidioc_enum_input              = bttv_enum_input,
3383         .vidioc_g_input                 = bttv_g_input,
3384         .vidioc_s_input                 = bttv_s_input,
3385         .vidioc_queryctrl               = bttv_queryctrl,
3386         .vidioc_g_ctrl                  = bttv_g_ctrl,
3387         .vidioc_s_ctrl                  = bttv_s_ctrl,
3388         .vidioc_streamon                = bttv_streamon,
3389         .vidioc_streamoff               = bttv_streamoff,
3390         .vidioc_g_tuner                 = bttv_g_tuner,
3391         .vidioc_s_tuner                 = bttv_s_tuner,
3392 #ifdef CONFIG_VIDEO_V4L1_COMPAT
3393         .vidiocgmbuf                    = vidiocgmbuf,
3394 #endif
3395         .vidioc_g_crop                  = bttv_g_crop,
3396         .vidioc_s_crop                  = bttv_s_crop,
3397         .vidioc_g_fbuf                  = bttv_g_fbuf,
3398         .vidioc_s_fbuf                  = bttv_s_fbuf,
3399         .vidioc_overlay                 = bttv_overlay,
3400         .vidioc_g_priority              = bttv_g_priority,
3401         .vidioc_s_priority              = bttv_s_priority,
3402         .vidioc_g_parm                  = bttv_g_parm,
3403         .vidioc_g_frequency             = bttv_g_frequency,
3404         .vidioc_s_frequency             = bttv_s_frequency,
3405         .vidioc_log_status              = bttv_log_status,
3406         .vidioc_querystd                = bttv_querystd,
3407 #ifdef CONFIG_VIDEO_ADV_DEBUG
3408         .vidioc_g_register              = bttv_g_register,
3409         .vidioc_s_register              = bttv_s_register,
3410 #endif
3411 };
3412
3413 static struct video_device bttv_video_template = {
3414         .fops         = &bttv_fops,
3415         .minor        = -1,
3416         .ioctl_ops    = &bttv_ioctl_ops,
3417         .tvnorms      = BTTV_NORMS,
3418         .current_norm = V4L2_STD_PAL,
3419 };
3420
3421 /* ----------------------------------------------------------------------- */
3422 /* radio interface                                                         */
3423
3424 static int radio_open(struct file *file)
3425 {
3426         int minor = video_devdata(file)->minor;
3427         struct bttv *btv = NULL;
3428         struct bttv_fh *fh;
3429         unsigned int i;
3430
3431         dprintk("bttv: open minor=%d\n",minor);
3432
3433         lock_kernel();
3434         for (i = 0; i < bttv_num; i++) {
3435                 if (bttvs[i].radio_dev && bttvs[i].radio_dev->minor == minor) {
3436                         btv = &bttvs[i];
3437                         break;
3438                 }
3439         }
3440         if (NULL == btv) {
3441                 unlock_kernel();
3442                 return -ENODEV;
3443         }
3444
3445         dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3446
3447         /* allocate per filehandle data */
3448         fh = kmalloc(sizeof(*fh), GFP_KERNEL);
3449         if (NULL == fh) {
3450                 unlock_kernel();
3451                 return -ENOMEM;
3452         }
3453         file->private_data = fh;
3454         *fh = btv->init;
3455         v4l2_prio_open(&btv->prio, &fh->prio);
3456
3457         mutex_lock(&btv->lock);
3458
3459         btv->radio_user++;
3460
3461         bttv_call_i2c_clients(btv,AUDC_SET_RADIO,NULL);
3462         audio_input(btv,TVAUDIO_INPUT_RADIO);
3463
3464         mutex_unlock(&btv->lock);
3465         unlock_kernel();
3466         return 0;
3467 }
3468
3469 static int radio_release(struct file *file)
3470 {
3471         struct bttv_fh *fh = file->private_data;
3472         struct bttv *btv = fh->btv;
3473         struct rds_command cmd;
3474
3475         v4l2_prio_close(&btv->prio,&fh->prio);
3476         file->private_data = NULL;
3477         kfree(fh);
3478
3479         btv->radio_user--;
3480
3481         bttv_call_i2c_clients(btv, RDS_CMD_CLOSE, &cmd);
3482
3483         return 0;
3484 }
3485
3486 static int radio_querycap(struct file *file, void *priv,
3487                                         struct v4l2_capability *cap)
3488 {
3489         struct bttv_fh *fh = priv;
3490         struct bttv *btv = fh->btv;
3491
3492         strcpy(cap->driver, "bttv");
3493         strlcpy(cap->card, btv->radio_dev->name, sizeof(cap->card));
3494         sprintf(cap->bus_info, "PCI:%s", pci_name(btv->c.pci));
3495         cap->version = BTTV_VERSION_CODE;
3496         cap->capabilities = V4L2_CAP_TUNER;
3497
3498         return 0;
3499 }
3500
3501 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3502 {
3503         struct bttv_fh *fh = priv;
3504         struct bttv *btv = fh->btv;
3505
3506         if (UNSET == bttv_tvcards[btv->c.type].tuner)
3507                 return -EINVAL;
3508         if (0 != t->index)
3509                 return -EINVAL;
3510         mutex_lock(&btv->lock);
3511         memset(t, 0, sizeof(*t));
3512         strcpy(t->name, "Radio");
3513         t->type = V4L2_TUNER_RADIO;
3514
3515         bttv_call_i2c_clients(btv, VIDIOC_G_TUNER, t);
3516
3517         if (btv->audio_mode_gpio)
3518                 btv->audio_mode_gpio(btv, t, 0);
3519
3520         mutex_unlock(&btv->lock);
3521
3522         return 0;
3523 }
3524
3525 static int radio_enum_input(struct file *file, void *priv,
3526                                 struct v4l2_input *i)
3527 {
3528         if (i->index != 0)
3529                 return -EINVAL;
3530
3531         strcpy(i->name, "Radio");
3532         i->type = V4L2_INPUT_TYPE_TUNER;
3533
3534         return 0;
3535 }
3536
3537 static int radio_g_audio(struct file *file, void *priv,
3538                                         struct v4l2_audio *a)
3539 {
3540         if (unlikely(a->index))
3541                 return -EINVAL;
3542
3543         strcpy(a->name, "Radio");
3544
3545         return 0;
3546 }
3547
3548 static int radio_s_tuner(struct file *file, void *priv,
3549                                         struct v4l2_tuner *t)
3550 {
3551         struct bttv_fh *fh = priv;
3552         struct bttv *btv = fh->btv;
3553
3554         if (0 != t->index)
3555                 return -EINVAL;
3556
3557         bttv_call_i2c_clients(btv, VIDIOC_G_TUNER, t);
3558         return 0;
3559 }
3560
3561 static int radio_s_audio(struct file *file, void *priv,
3562                                         struct v4l2_audio *a)
3563 {
3564         if (unlikely(a->index))
3565                 return -EINVAL;
3566
3567         return 0;
3568 }
3569
3570 static int radio_s_input(struct file *filp, void *priv, unsigned int i)
3571 {
3572         if (unlikely(i))
3573                 return -EINVAL;
3574
3575         return 0;
3576 }
3577
3578 static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
3579 {
3580         return 0;
3581 }
3582
3583 static int radio_queryctrl(struct file *file, void *priv,
3584                                         struct v4l2_queryctrl *c)
3585 {
3586         const struct v4l2_queryctrl *ctrl;
3587
3588         if (c->id <  V4L2_CID_BASE ||
3589                         c->id >= V4L2_CID_LASTP1)
3590                 return -EINVAL;
3591
3592         if (c->id == V4L2_CID_AUDIO_MUTE) {
3593                 ctrl = ctrl_by_id(c->id);
3594                 *c = *ctrl;
3595         } else
3596                 *c = no_ctl;
3597
3598         return 0;
3599 }
3600
3601 static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
3602 {
3603         *i = 0;
3604         return 0;
3605 }
3606
3607 static ssize_t radio_read(struct file *file, char __user *data,
3608                          size_t count, loff_t *ppos)
3609 {
3610         struct bttv_fh *fh = file->private_data;
3611         struct bttv *btv = fh->btv;
3612         struct rds_command cmd;
3613         cmd.block_count = count/3;
3614         cmd.buffer = data;
3615         cmd.instance = file;
3616         cmd.result = -ENODEV;
3617
3618         bttv_call_i2c_clients(btv, RDS_CMD_READ, &cmd);
3619
3620         return cmd.result;
3621 }
3622
3623 static unsigned int radio_poll(struct file *file, poll_table *wait)
3624 {
3625         struct bttv_fh *fh = file->private_data;
3626         struct bttv *btv = fh->btv;
3627         struct rds_command cmd;
3628         cmd.instance = file;
3629         cmd.event_list = wait;
3630         cmd.result = -ENODEV;
3631         bttv_call_i2c_clients(btv, RDS_CMD_POLL, &cmd);
3632
3633         return cmd.result;
3634 }
3635
3636 static const struct v4l2_file_operations radio_fops =
3637 {
3638         .owner    = THIS_MODULE,
3639         .open     = radio_open,
3640         .read     = radio_read,
3641         .release  = radio_release,
3642         .ioctl    = video_ioctl2,
3643         .poll     = radio_poll,
3644 };
3645
3646 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
3647         .vidioc_querycap        = radio_querycap,
3648         .vidioc_g_tuner         = radio_g_tuner,
3649         .vidioc_enum_input      = radio_enum_input,
3650         .vidioc_g_audio         = radio_g_audio,
3651         .vidioc_s_tuner         = radio_s_tuner,
3652         .vidioc_s_audio         = radio_s_audio,
3653         .vidioc_s_input         = radio_s_input,
3654         .vidioc_s_std           = radio_s_std,
3655         .vidioc_queryctrl       = radio_queryctrl,
3656         .vidioc_g_input         = radio_g_input,
3657         .vidioc_g_ctrl          = bttv_g_ctrl,
3658         .vidioc_s_ctrl          = bttv_s_ctrl,
3659         .vidioc_g_frequency     = bttv_g_frequency,
3660         .vidioc_s_frequency     = bttv_s_frequency,
3661 };
3662
3663 static struct video_device radio_template = {
3664         .fops      = &radio_fops,
3665         .minor     = -1,
3666         .ioctl_ops = &radio_ioctl_ops,
3667 };
3668
3669 /* ----------------------------------------------------------------------- */
3670 /* some debug code                                                         */
3671
3672 static int bttv_risc_decode(u32 risc)
3673 {
3674         static char *instr[16] = {
3675                 [ BT848_RISC_WRITE     >> 28 ] = "write",
3676                 [ BT848_RISC_SKIP      >> 28 ] = "skip",
3677                 [ BT848_RISC_WRITEC    >> 28 ] = "writec",
3678                 [ BT848_RISC_JUMP      >> 28 ] = "jump",
3679                 [ BT848_RISC_SYNC      >> 28 ] = "sync",
3680                 [ BT848_RISC_WRITE123  >> 28 ] = "write123",
3681                 [ BT848_RISC_SKIP123   >> 28 ] = "skip123",
3682                 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3683         };
3684         static int incr[16] = {
3685                 [ BT848_RISC_WRITE     >> 28 ] = 2,
3686                 [ BT848_RISC_JUMP      >> 28 ] = 2,
3687                 [ BT848_RISC_SYNC      >> 28 ] = 2,
3688                 [ BT848_RISC_WRITE123  >> 28 ] = 5,
3689                 [ BT848_RISC_SKIP123   >> 28 ] = 2,
3690                 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3691         };
3692         static char *bits[] = {
3693                 "be0",  "be1",  "be2",  "be3/resync",
3694                 "set0", "set1", "set2", "set3",
3695                 "clr0", "clr1", "clr2", "clr3",
3696                 "irq",  "res",  "eol",  "sol",
3697         };
3698         int i;
3699
3700         printk("0x%08x [ %s", risc,
3701                instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3702         for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3703                 if (risc & (1 << (i + 12)))
3704                         printk(" %s",bits[i]);
3705         printk(" count=%d ]\n", risc & 0xfff);
3706         return incr[risc >> 28] ? incr[risc >> 28] : 1;
3707 }
3708
3709 static void bttv_risc_disasm(struct bttv *btv,
3710                              struct btcx_riscmem *risc)
3711 {
3712         unsigned int i,j,n;
3713
3714         printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3715                btv->c.name, risc->cpu, (unsigned long)risc->dma);
3716         for (i = 0; i < (risc->size >> 2); i += n) {
3717                 printk("%s:   0x%lx: ", btv->c.name,
3718                        (unsigned long)(risc->dma + (i<<2)));
3719                 n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
3720                 for (j = 1; j < n; j++)
3721                         printk("%s:   0x%lx: 0x%08x [ arg #%d ]\n",
3722                                btv->c.name, (unsigned long)(risc->dma + ((i+j)<<2)),
3723                                risc->cpu[i+j], j);
3724                 if (0 == risc->cpu[i])
3725                         break;
3726         }
3727 }
3728
3729 static void bttv_print_riscaddr(struct bttv *btv)
3730 {
3731         printk("  main: %08Lx\n",
3732                (unsigned long long)btv->main.dma);
3733         printk("  vbi : o=%08Lx e=%08Lx\n",
3734                btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3735                btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3736         printk("  cap : o=%08Lx e=%08Lx\n",
3737                btv->curr.top    ? (unsigned long long)btv->curr.top->top.dma : 0,
3738                btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3739         printk("  scr : o=%08Lx e=%08Lx\n",
3740                btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3741                btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3742         bttv_risc_disasm(btv, &btv->main);
3743 }
3744
3745 /* ----------------------------------------------------------------------- */
3746 /* irq handler                                                             */
3747
3748 static char *irq_name[] = {
3749         "FMTCHG",  // format change detected (525 vs. 625)
3750         "VSYNC",   // vertical sync (new field)
3751         "HSYNC",   // horizontal sync
3752         "OFLOW",   // chroma/luma AGC overflow
3753         "HLOCK",   // horizontal lock changed
3754         "VPRES",   // video presence changed
3755         "6", "7",
3756         "I2CDONE", // hw irc operation finished
3757         "GPINT",   // gpio port triggered irq
3758         "10",
3759         "RISCI",   // risc instruction triggered irq
3760         "FBUS",    // pixel data fifo dropped data (high pci bus latencies)
3761         "FTRGT",   // pixel data fifo overrun
3762         "FDSR",    // fifo data stream resyncronisation
3763         "PPERR",   // parity error (data transfer)
3764         "RIPERR",  // parity error (read risc instructions)
3765         "PABORT",  // pci abort
3766         "OCERR",   // risc instruction error
3767         "SCERR",   // syncronisation error
3768 };
3769
3770 static void bttv_print_irqbits(u32 print, u32 mark)
3771 {
3772         unsigned int i;
3773
3774         printk("bits:");
3775         for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3776                 if (print & (1 << i))
3777                         printk(" %s",irq_name[i]);
3778                 if (mark & (1 << i))
3779                         printk("*");
3780         }
3781 }
3782
3783 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3784 {
3785         printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3786                btv->c.nr,
3787                (unsigned long)btv->main.dma,
3788                (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
3789                (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
3790                (unsigned long)rc);
3791
3792         if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3793                 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3794                        "Ok, then this is harmless, don't worry ;)\n",
3795                        btv->c.nr);
3796                 return;
3797         }
3798         printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3799                btv->c.nr);
3800         printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3801                btv->c.nr);
3802         dump_stack();
3803 }
3804
3805 static int
3806 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3807 {
3808         struct bttv_buffer *item;
3809
3810         memset(set,0,sizeof(*set));
3811
3812         /* capture request ? */
3813         if (!list_empty(&btv->capture)) {
3814                 set->frame_irq = 1;
3815                 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3816                 if (V4L2_FIELD_HAS_TOP(item->vb.field))
3817                         set->top    = item;
3818                 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3819                         set->bottom = item;
3820
3821                 /* capture request for other field ? */
3822                 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3823                     (item->vb.queue.next != &btv->capture)) {
3824                         item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3825                         if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3826                                 if (NULL == set->top &&
3827                                     V4L2_FIELD_TOP == item->vb.field) {
3828                                         set->top = item;
3829                                 }
3830                                 if (NULL == set->bottom &&
3831                                     V4L2_FIELD_BOTTOM == item->vb.field) {
3832                                         set->bottom = item;
3833                                 }
3834                                 if (NULL != set->top  &&  NULL != set->bottom)
3835                                         set->top_irq = 2;
3836                         }
3837                 }
3838         }
3839
3840         /* screen overlay ? */
3841         if (NULL != btv->screen) {
3842                 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3843                         if (NULL == set->top && NULL == set->bottom) {
3844                                 set->top    = btv->screen;
3845                                 set->bottom = btv->screen;
3846                         }
3847                 } else {
3848                         if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3849                             NULL == set->top) {
3850                                 set->top = btv->screen;
3851                         }
3852                         if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3853                             NULL == set->bottom) {
3854                                 set->bottom = btv->screen;
3855                         }
3856                 }
3857         }
3858
3859         dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3860                 btv->c.nr,set->top, set->bottom,
3861                 btv->screen,set->frame_irq,set->top_irq);
3862         return 0;
3863 }
3864
3865 static void
3866 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3867                       struct bttv_buffer_set *curr, unsigned int state)
3868 {
3869         struct timeval ts;
3870
3871         do_gettimeofday(&ts);
3872
3873         if (wakeup->top == wakeup->bottom) {
3874                 if (NULL != wakeup->top && curr->top != wakeup->top) {
3875                         if (irq_debug > 1)
3876                                 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
3877                         wakeup->top->vb.ts = ts;
3878                         wakeup->top->vb.field_count = btv->field_count;
3879                         wakeup->top->vb.state = state;
3880                         wake_up(&wakeup->top->vb.done);
3881                 }
3882         } else {
3883                 if (NULL != wakeup->top && curr->top != wakeup->top) {
3884                         if (irq_debug > 1)
3885                                 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
3886                         wakeup->top->vb.ts = ts;
3887                         wakeup->top->vb.field_count = btv->field_count;
3888                         wakeup->top->vb.state = state;
3889                         wake_up(&wakeup->top->vb.done);
3890                 }
3891                 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3892                         if (irq_debug > 1)
3893                                 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
3894                         wakeup->bottom->vb.ts = ts;
3895                         wakeup->bottom->vb.field_count = btv->field_count;
3896                         wakeup->bottom->vb.state = state;
3897                         wake_up(&wakeup->bottom->vb.done);
3898                 }
3899         }
3900 }
3901
3902 static void
3903 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3904                     unsigned int state)
3905 {
3906         struct timeval ts;
3907
3908         if (NULL == wakeup)
3909                 return;
3910
3911         do_gettimeofday(&ts);
3912         wakeup->vb.ts = ts;
3913         wakeup->vb.field_count = btv->field_count;
3914         wakeup->vb.state = state;
3915         wake_up(&wakeup->vb.done);
3916 }
3917
3918 static void bttv_irq_timeout(unsigned long data)
3919 {
3920         struct bttv *btv = (struct bttv *)data;
3921         struct bttv_buffer_set old,new;
3922         struct bttv_buffer *ovbi;
3923         struct bttv_buffer *item;
3924         unsigned long flags;
3925
3926         if (bttv_verbose) {
3927                 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3928                        btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3929                        btread(BT848_RISC_COUNT));
3930                 bttv_print_irqbits(btread(BT848_INT_STAT),0);
3931                 printk("\n");
3932         }
3933
3934         spin_lock_irqsave(&btv->s_lock,flags);
3935
3936         /* deactivate stuff */
3937         memset(&new,0,sizeof(new));
3938         old  = btv->curr;
3939         ovbi = btv->cvbi;
3940         btv->curr = new;
3941         btv->cvbi = NULL;
3942         btv->loop_irq = 0;
3943         bttv_buffer_activate_video(btv, &new);
3944         bttv_buffer_activate_vbi(btv,   NULL);
3945         bttv_set_dma(btv, 0);
3946
3947         /* wake up */
3948         bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
3949         bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
3950
3951         /* cancel all outstanding capture / vbi requests */
3952         while (!list_empty(&btv->capture)) {
3953                 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3954                 list_del(&item->vb.queue);
3955                 item->vb.state = VIDEOBUF_ERROR;
3956                 wake_up(&item->vb.done);
3957         }
3958         while (!list_empty(&btv->vcapture)) {
3959                 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3960                 list_del(&item->vb.queue);
3961                 item->vb.state = VIDEOBUF_ERROR;
3962                 wake_up(&item->vb.done);
3963         }
3964
3965         btv->errors++;
3966         spin_unlock_irqrestore(&btv->s_lock,flags);
3967 }
3968
3969 static void
3970 bttv_irq_wakeup_top(struct bttv *btv)
3971 {
3972         struct bttv_buffer *wakeup = btv->curr.top;
3973
3974         if (NULL == wakeup)
3975                 return;
3976
3977         spin_lock(&btv->s_lock);
3978         btv->curr.top_irq = 0;
3979         btv->curr.top = NULL;
3980         bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3981
3982         do_gettimeofday(&wakeup->vb.ts);
3983         wakeup->vb.field_count = btv->field_count;
3984         wakeup->vb.state = VIDEOBUF_DONE;
3985         wake_up(&wakeup->vb.done);
3986         spin_unlock(&btv->s_lock);
3987 }
3988
3989 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
3990 {
3991         if (rc < risc->dma)
3992                 return 0;
3993         if (rc > risc->dma + risc->size)
3994                 return 0;
3995         return 1;
3996 }
3997
3998 static void
3999 bttv_irq_switch_video(struct bttv *btv)
4000 {
4001         struct bttv_buffer_set new;
4002         struct bttv_buffer_set old;
4003         dma_addr_t rc;
4004
4005         spin_lock(&btv->s_lock);
4006
4007         /* new buffer set */
4008         bttv_irq_next_video(btv, &new);
4009         rc = btread(BT848_RISC_COUNT);
4010         if ((btv->curr.top    && is_active(&btv->curr.top->top,       rc)) ||
4011             (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
4012                 btv->framedrop++;
4013                 if (debug_latency)
4014                         bttv_irq_debug_low_latency(btv, rc);
4015                 spin_unlock(&btv->s_lock);
4016                 return;
4017         }
4018
4019         /* switch over */
4020         old = btv->curr;
4021         btv->curr = new;
4022         btv->loop_irq &= ~1;
4023         bttv_buffer_activate_video(btv, &new);
4024         bttv_set_dma(btv, 0);
4025
4026         /* switch input */
4027         if (UNSET != btv->new_input) {
4028                 video_mux(btv,btv->new_input);
4029                 btv->new_input = UNSET;
4030         }
4031
4032         /* wake up finished buffers */
4033         bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
4034         spin_unlock(&btv->s_lock);
4035 }
4036
4037 static void
4038 bttv_irq_switch_vbi(struct bttv *btv)
4039 {
4040         struct bttv_buffer *new = NULL;
4041         struct bttv_buffer *old;
4042         u32 rc;
4043
4044         spin_lock(&btv->s_lock);
4045
4046         if (!list_empty(&btv->vcapture))
4047                 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4048         old = btv->cvbi;
4049
4050         rc = btread(BT848_RISC_COUNT);
4051         if (NULL != old && (is_active(&old->top,    rc) ||
4052                             is_active(&old->bottom, rc))) {
4053                 btv->framedrop++;
4054                 if (debug_latency)
4055                         bttv_irq_debug_low_latency(btv, rc);
4056                 spin_unlock(&btv->s_lock);
4057                 return;
4058         }
4059
4060         /* switch */
4061         btv->cvbi = new;
4062         btv->loop_irq &= ~4;
4063         bttv_buffer_activate_vbi(btv, new);
4064         bttv_set_dma(btv, 0);
4065
4066         bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
4067         spin_unlock(&btv->s_lock);
4068 }
4069
4070 static irqreturn_t bttv_irq(int irq, void *dev_id)
4071 {
4072         u32 stat,astat;
4073         u32 dstat;
4074         int count;
4075         struct bttv *btv;
4076         int handled = 0;
4077
4078         btv=(struct bttv *)dev_id;
4079
4080         if (btv->custom_irq)
4081                 handled = btv->custom_irq(btv);
4082
4083         count=0;
4084         while (1) {
4085                 /* get/clear interrupt status bits */
4086                 stat=btread(BT848_INT_STAT);
4087                 astat=stat&btread(BT848_INT_MASK);
4088                 if (!astat)
4089                         break;
4090                 handled = 1;
4091                 btwrite(stat,BT848_INT_STAT);
4092
4093                 /* get device status bits */
4094                 dstat=btread(BT848_DSTATUS);
4095
4096                 if (irq_debug) {
4097                         printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
4098                                "riscs=%x, riscc=%08x, ",
4099                                btv->c.nr, count, btv->field_count,
4100                                stat>>28, btread(BT848_RISC_COUNT));
4101                         bttv_print_irqbits(stat,astat);
4102                         if (stat & BT848_INT_HLOCK)
4103                                 printk("   HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
4104                                        ? "yes" : "no");
4105                         if (stat & BT848_INT_VPRES)
4106                                 printk("   PRES => %s", (dstat & BT848_DSTATUS_PRES)
4107                                        ? "yes" : "no");
4108                         if (stat & BT848_INT_FMTCHG)
4109                                 printk("   NUML => %s", (dstat & BT848_DSTATUS_NUML)
4110                                        ? "625" : "525");
4111                         printk("\n");
4112                 }
4113
4114                 if (astat&BT848_INT_VSYNC)
4115                         btv->field_count++;
4116
4117                 if ((astat & BT848_INT_GPINT) && btv->remote) {
4118                         wake_up(&btv->gpioq);
4119                         bttv_input_irq(btv);
4120                 }
4121
4122                 if (astat & BT848_INT_I2CDONE) {
4123                         btv->i2c_done = stat;
4124                         wake_up(&btv->i2c_queue);
4125                 }
4126
4127                 if ((astat & BT848_INT_RISCI)  &&  (stat & (4<<28)))
4128                         bttv_irq_switch_vbi(btv);
4129
4130                 if ((astat & BT848_INT_RISCI)  &&  (stat & (2<<28)))
4131                         bttv_irq_wakeup_top(btv);
4132
4133                 if ((astat & BT848_INT_RISCI)  &&  (stat & (1<<28)))
4134                         bttv_irq_switch_video(btv);
4135
4136                 if ((astat & BT848_INT_HLOCK)  &&  btv->opt_automute)
4137                         audio_mute(btv, btv->mute);  /* trigger automute */
4138
4139                 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
4140                         printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
4141                                (astat & BT848_INT_SCERR) ? "SCERR" : "",
4142                                (astat & BT848_INT_OCERR) ? "OCERR" : "",
4143                                btread(BT848_RISC_COUNT));
4144                         bttv_print_irqbits(stat,astat);
4145                         printk("\n");
4146                         if (bttv_debug)
4147                                 bttv_print_riscaddr(btv);
4148                 }
4149                 if (fdsr && astat & BT848_INT_FDSR) {
4150                         printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
4151                                btv->c.nr,btread(BT848_RISC_COUNT));
4152                         if (bttv_debug)
4153                                 bttv_print_riscaddr(btv);
4154                 }
4155
4156                 count++;
4157                 if (count > 4) {
4158
4159                         if (count > 8 || !(astat & BT848_INT_GPINT)) {
4160                                 btwrite(0, BT848_INT_MASK);
4161
4162                                 printk(KERN_ERR
4163                                            "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
4164                         } else {
4165                                 printk(KERN_ERR
4166                                            "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
4167
4168                                 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
4169                                                 BT848_INT_MASK);
4170                         };
4171
4172                         bttv_print_irqbits(stat,astat);
4173
4174                         printk("]\n");
4175                 }
4176         }
4177         btv->irq_total++;
4178         if (handled)
4179                 btv->irq_me++;
4180         return IRQ_RETVAL(handled);
4181 }
4182
4183
4184 /* ----------------------------------------------------------------------- */
4185 /* initialitation                                                          */
4186
4187 static struct video_device *vdev_init(struct bttv *btv,
4188                                       const struct video_device *template,
4189                                       const char *type_name)
4190 {
4191         struct video_device *vfd;
4192
4193         vfd = video_device_alloc();
4194         if (NULL == vfd)
4195                 return NULL;
4196         *vfd = *template;
4197         vfd->minor   = -1;
4198         vfd->parent  = &btv->c.pci->dev;
4199         vfd->release = video_device_release;
4200         vfd->debug   = bttv_debug;
4201         snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
4202                  btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
4203                  type_name, bttv_tvcards[btv->c.type].name);
4204         return vfd;
4205 }
4206
4207 static void bttv_unregister_video(struct bttv *btv)
4208 {
4209         if (btv->video_dev) {
4210                 if (-1 != btv->video_dev->minor)
4211                         video_unregister_device(btv->video_dev);
4212                 else
4213                         video_device_release(btv->video_dev);
4214                 btv->video_dev = NULL;
4215         }
4216         if (btv->vbi_dev) {
4217                 if (-1 != btv->vbi_dev->minor)
4218                         video_unregister_device(btv->vbi_dev);
4219                 else
4220                         video_device_release(btv->vbi_dev);
4221                 btv->vbi_dev = NULL;
4222         }
4223         if (btv->radio_dev) {
4224                 if (-1 != btv->radio_dev->minor)
4225                         video_unregister_device(btv->radio_dev);
4226                 else
4227                         video_device_release(btv->radio_dev);
4228                 btv->radio_dev = NULL;
4229         }
4230 }
4231
4232 /* register video4linux devices */
4233 static int __devinit bttv_register_video(struct bttv *btv)
4234 {
4235         if (no_overlay > 0)
4236                 printk("bttv: Overlay support disabled.\n");
4237
4238         /* video */
4239         btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
4240
4241         if (NULL == btv->video_dev)
4242                 goto err;
4243         if (video_register_device(btv->video_dev, VFL_TYPE_GRABBER,
4244                                   video_nr[btv->c.nr]) < 0)
4245                 goto err;
4246         printk(KERN_INFO "bttv%d: registered device video%d\n",
4247                btv->c.nr, btv->video_dev->num);
4248         if (device_create_file(&btv->video_dev->dev,
4249                                      &dev_attr_card)<0) {
4250                 printk(KERN_ERR "bttv%d: device_create_file 'card' "
4251                        "failed\n", btv->c.nr);
4252                 goto err;
4253         }
4254
4255         /* vbi */
4256         btv->vbi_dev = vdev_init(btv, &bttv_video_template, "vbi");
4257
4258         if (NULL == btv->vbi_dev)
4259                 goto err;
4260         if (video_register_device(btv->vbi_dev, VFL_TYPE_VBI,
4261                                   vbi_nr[btv->c.nr]) < 0)
4262                 goto err;
4263         printk(KERN_INFO "bttv%d: registered device vbi%d\n",
4264                btv->c.nr, btv->vbi_dev->num);
4265
4266         if (!btv->has_radio)
4267                 return 0;
4268         /* radio */
4269         btv->radio_dev = vdev_init(btv, &radio_template, "radio");
4270         if (NULL == btv->radio_dev)
4271                 goto err;
4272         if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,
4273                                   radio_nr[btv->c.nr]) < 0)
4274                 goto err;
4275         printk(KERN_INFO "bttv%d: registered device radio%d\n",
4276                btv->c.nr, btv->radio_dev->num);
4277
4278         /* all done */
4279         return 0;
4280
4281  err:
4282         bttv_unregister_video(btv);
4283         return -1;
4284 }
4285
4286
4287 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
4288 /* response on cards with no firmware is not enabled by OF */
4289 static void pci_set_command(struct pci_dev *dev)
4290 {
4291 #if defined(__powerpc__)
4292         unsigned int cmd;
4293
4294         pci_read_config_dword(dev, PCI_COMMAND, &cmd);
4295         cmd = (cmd | PCI_COMMAND_MEMORY );
4296         pci_write_config_dword(dev, PCI_COMMAND, cmd);
4297 #endif
4298 }
4299
4300 static int __devinit bttv_probe(struct pci_dev *dev,
4301                                 const struct pci_device_id *pci_id)
4302 {
4303         int result;
4304         unsigned char lat;
4305         struct bttv *btv;
4306
4307         if (bttv_num == BTTV_MAX)
4308                 return -ENOMEM;
4309         printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
4310         btv=&bttvs[bttv_num];
4311         memset(btv,0,sizeof(*btv));
4312         btv->c.nr  = bttv_num;
4313         sprintf(btv->c.name,"bttv%d",btv->c.nr);
4314
4315         /* initialize structs / fill in defaults */
4316         mutex_init(&btv->lock);
4317         spin_lock_init(&btv->s_lock);
4318         spin_lock_init(&btv->gpio_lock);
4319         init_waitqueue_head(&btv->gpioq);
4320         init_waitqueue_head(&btv->i2c_queue);
4321         INIT_LIST_HEAD(&btv->c.subs);
4322         INIT_LIST_HEAD(&btv->capture);
4323         INIT_LIST_HEAD(&btv->vcapture);
4324         v4l2_prio_init(&btv->prio);
4325
4326         init_timer(&btv->timeout);
4327         btv->timeout.function = bttv_irq_timeout;
4328         btv->timeout.data     = (unsigned long)btv;
4329
4330         btv->i2c_rc = -1;
4331         btv->tuner_type  = UNSET;
4332         btv->new_input   = UNSET;
4333         btv->has_radio=radio[btv->c.nr];
4334
4335         /* pci stuff (init, get irq/mmio, ... */
4336         btv->c.pci = dev;
4337         btv->id  = dev->device;
4338         if (pci_enable_device(dev)) {
4339                 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4340                        btv->c.nr);
4341                 return -EIO;
4342         }
4343         if (pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
4344                 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
4345                        btv->c.nr);
4346                 return -EIO;
4347         }
4348         if (!request_mem_region(pci_resource_start(dev,0),
4349                                 pci_resource_len(dev,0),
4350                                 btv->c.name)) {
4351                 printk(KERN_WARNING "bttv%d: can't request iomem (0x%llx).\n",
4352                        btv->c.nr,
4353                        (unsigned long long)pci_resource_start(dev,0));
4354                 return -EBUSY;
4355         }
4356         pci_set_master(dev);
4357         pci_set_command(dev);
4358         pci_set_drvdata(dev,btv);
4359
4360         pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
4361         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4362         printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
4363                bttv_num,btv->id, btv->revision, pci_name(dev));
4364         printk("irq: %d, latency: %d, mmio: 0x%llx\n",
4365                btv->c.pci->irq, lat,
4366                (unsigned long long)pci_resource_start(dev,0));
4367         schedule();
4368
4369         btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4370         if (NULL == btv->bt848_mmio) {
4371                 printk("bttv%d: ioremap() failed\n", btv->c.nr);
4372                 result = -EIO;
4373                 goto fail1;
4374         }
4375
4376         /* identify card */
4377         bttv_idcard(btv);
4378
4379         /* disable irqs, register irq handler */
4380         btwrite(0, BT848_INT_MASK);
4381         result = request_irq(btv->c.pci->irq, bttv_irq,
4382                              IRQF_SHARED | IRQF_DISABLED,btv->c.name,(void *)btv);
4383         if (result < 0) {
4384                 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
4385                        bttv_num,btv->c.pci->irq);
4386                 goto fail1;
4387         }
4388
4389         if (0 != bttv_handle_chipset(btv)) {
4390                 result = -EIO;
4391                 goto fail2;
4392         }
4393
4394         /* init options from insmod args */
4395         btv->opt_combfilter = combfilter;
4396         btv->opt_lumafilter = lumafilter;
4397         btv->opt_automute   = automute;
4398         btv->opt_chroma_agc = chroma_agc;
4399         btv->opt_adc_crush  = adc_crush;
4400         btv->opt_vcr_hack   = vcr_hack;
4401         btv->opt_whitecrush_upper  = whitecrush_upper;
4402         btv->opt_whitecrush_lower  = whitecrush_lower;
4403         btv->opt_uv_ratio   = uv_ratio;
4404         btv->opt_full_luma_range   = full_luma_range;
4405         btv->opt_coring     = coring;
4406
4407         /* fill struct bttv with some useful defaults */
4408         btv->init.btv         = btv;
4409         btv->init.ov.w.width  = 320;
4410         btv->init.ov.w.height = 240;
4411         btv->init.fmt         = format_by_fourcc(V4L2_PIX_FMT_BGR24);
4412         btv->init.width       = 320;
4413         btv->init.height      = 240;
4414         btv->input = 0;
4415
4416         /* initialize hardware */
4417         if (bttv_gpio)
4418                 bttv_gpio_tracking(btv,"pre-init");
4419
4420         bttv_risc_init_main(btv);
4421         init_bt848(btv);
4422
4423         /* gpio */
4424         btwrite(0x00, BT848_GPIO_REG_INP);
4425         btwrite(0x00, BT848_GPIO_OUT_EN);
4426         if (bttv_verbose)
4427                 bttv_gpio_tracking(btv,"init");
4428
4429         /* needs to be done before i2c is registered */
4430         bttv_init_card1(btv);
4431
4432         /* register i2c + gpio */
4433         init_bttv_i2c(btv);
4434
4435         /* some card-specific stuff (needs working i2c) */
4436         bttv_init_card2(btv);
4437         init_irqreg(btv);
4438
4439         /* register video4linux + input */
4440         if (!bttv_tvcards[btv->c.type].no_video) {
4441                 bttv_register_video(btv);
4442                 bt848_bright(btv,32768);
4443                 bt848_contrast(btv,32768);
4444                 bt848_hue(btv,32768);
4445                 bt848_sat(btv,32768);
4446                 audio_mute(btv, 1);
4447                 set_input(btv, 0, btv->tvnorm);
4448                 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4449                 btv->crop[1] = btv->crop[0]; /* current = default */
4450                 disclaim_vbi_lines(btv);
4451                 disclaim_video_lines(btv);
4452         }
4453
4454         /* add subdevices and autoload dvb-bt8xx if needed */
4455         if (bttv_tvcards[btv->c.type].has_dvb) {
4456                 bttv_sub_add_device(&btv->c, "dvb");
4457                 request_modules(btv);
4458         }
4459
4460         bttv_input_init(btv);
4461
4462         /* everything is fine */
4463         bttv_num++;
4464         return 0;
4465
4466  fail2:
4467         free_irq(btv->c.pci->irq,btv);
4468
4469  fail1:
4470         if (btv->bt848_mmio)
4471                 iounmap(btv->bt848_mmio);
4472         release_mem_region(pci_resource_start(btv->c.pci,0),
4473                            pci_resource_len(btv->c.pci,0));
4474         pci_set_drvdata(dev,NULL);
4475         return result;
4476 }
4477
4478 static void __devexit bttv_remove(struct pci_dev *pci_dev)
4479 {
4480         struct bttv *btv = pci_get_drvdata(pci_dev);
4481
4482         if (bttv_verbose)
4483                 printk("bttv%d: unloading\n",btv->c.nr);
4484
4485         /* shutdown everything (DMA+IRQs) */
4486         btand(~15, BT848_GPIO_DMA_CTL);
4487         btwrite(0, BT848_INT_MASK);
4488         btwrite(~0x0, BT848_INT_STAT);
4489         btwrite(0x0, BT848_GPIO_OUT_EN);
4490         if (bttv_gpio)
4491                 bttv_gpio_tracking(btv,"cleanup");
4492
4493         /* tell gpio modules we are leaving ... */
4494         btv->shutdown=1;
4495         wake_up(&btv->gpioq);
4496         bttv_input_fini(btv);
4497         bttv_sub_del_devices(&btv->c);
4498
4499         /* unregister i2c_bus + input */
4500         fini_bttv_i2c(btv);
4501
4502         /* unregister video4linux */
4503         bttv_unregister_video(btv);
4504
4505         /* free allocated memory */
4506         btcx_riscmem_free(btv->c.pci,&btv->main);
4507
4508         /* free ressources */
4509         free_irq(btv->c.pci->irq,btv);
4510         iounmap(btv->bt848_mmio);
4511         release_mem_region(pci_resource_start(btv->c.pci,0),
4512                            pci_resource_len(btv->c.pci,0));
4513
4514         pci_set_drvdata(pci_dev, NULL);
4515         return;
4516 }
4517
4518 #ifdef CONFIG_PM
4519 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4520 {
4521         struct bttv *btv = pci_get_drvdata(pci_dev);
4522         struct bttv_buffer_set idle;
4523         unsigned long flags;
4524
4525         dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
4526
4527         /* stop dma + irqs */
4528         spin_lock_irqsave(&btv->s_lock,flags);
4529         memset(&idle, 0, sizeof(idle));
4530         btv->state.video = btv->curr;
4531         btv->state.vbi   = btv->cvbi;
4532         btv->state.loop_irq = btv->loop_irq;
4533         btv->curr = idle;
4534         btv->loop_irq = 0;
4535         bttv_buffer_activate_video(btv, &idle);
4536         bttv_buffer_activate_vbi(btv, NULL);
4537         bttv_set_dma(btv, 0);
4538         btwrite(0, BT848_INT_MASK);
4539         spin_unlock_irqrestore(&btv->s_lock,flags);
4540
4541         /* save bt878 state */
4542         btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4543         btv->state.gpio_data   = gpio_read();
4544
4545         /* save pci state */
4546         pci_save_state(pci_dev);
4547         if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4548                 pci_disable_device(pci_dev);
4549                 btv->state.disabled = 1;
4550         }
4551         return 0;
4552 }
4553
4554 static int bttv_resume(struct pci_dev *pci_dev)
4555 {
4556         struct bttv *btv = pci_get_drvdata(pci_dev);
4557         unsigned long flags;
4558         int err;
4559
4560         dprintk("bttv%d: resume\n", btv->c.nr);
4561
4562         /* restore pci state */
4563         if (btv->state.disabled) {
4564                 err=pci_enable_device(pci_dev);
4565                 if (err) {
4566                         printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4567                                                                 btv->c.nr);
4568                         return err;
4569                 }
4570                 btv->state.disabled = 0;
4571         }
4572         err=pci_set_power_state(pci_dev, PCI_D0);
4573         if (err) {
4574                 pci_disable_device(pci_dev);
4575                 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4576                                                         btv->c.nr);
4577                 btv->state.disabled = 1;
4578                 return err;
4579         }
4580
4581         pci_restore_state(pci_dev);
4582
4583         /* restore bt878 state */
4584         bttv_reinit_bt848(btv);
4585         gpio_inout(0xffffff, btv->state.gpio_enable);
4586         gpio_write(btv->state.gpio_data);
4587
4588         /* restart dma */
4589         spin_lock_irqsave(&btv->s_lock,flags);
4590         btv->curr = btv->state.video;
4591         btv->cvbi = btv->state.vbi;
4592         btv->loop_irq = btv->state.loop_irq;
4593         bttv_buffer_activate_video(btv, &btv->curr);
4594         bttv_buffer_activate_vbi(btv, btv->cvbi);
4595         bttv_set_dma(btv, 0);
4596         spin_unlock_irqrestore(&btv->s_lock,flags);
4597         return 0;
4598 }
4599 #endif
4600
4601 static struct pci_device_id bttv_pci_tbl[] = {
4602         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
4603          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4604         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
4605          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4606         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
4607          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4608         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
4609          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4610         {0,}
4611 };
4612
4613 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4614
4615 static struct pci_driver bttv_pci_driver = {
4616         .name     = "bttv",
4617         .id_table = bttv_pci_tbl,
4618         .probe    = bttv_probe,
4619         .remove   = __devexit_p(bttv_remove),
4620 #ifdef CONFIG_PM
4621         .suspend  = bttv_suspend,
4622         .resume   = bttv_resume,
4623 #endif
4624 };
4625
4626 static int __init bttv_init_module(void)
4627 {
4628         int ret;
4629
4630         bttv_num = 0;
4631
4632         printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4633                (BTTV_VERSION_CODE >> 16) & 0xff,
4634                (BTTV_VERSION_CODE >> 8) & 0xff,
4635                BTTV_VERSION_CODE & 0xff);
4636 #ifdef SNAPSHOT
4637         printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4638                SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4639 #endif
4640         if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4641                 gbuffers = 2;
4642         if (gbufsize < 0 || gbufsize > BTTV_MAX_FBUF)
4643                 gbufsize = BTTV_MAX_FBUF;
4644         gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4645         if (bttv_verbose)
4646                 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4647                        gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4648
4649         bttv_check_chipset();
4650
4651         ret = bus_register(&bttv_sub_bus_type);
4652         if (ret < 0) {
4653                 printk(KERN_WARNING "bttv: bus_register error: %d\n", ret);
4654                 return ret;
4655         }
4656         ret = pci_register_driver(&bttv_pci_driver);
4657         if (ret < 0)
4658                 bus_unregister(&bttv_sub_bus_type);
4659
4660         return ret;
4661 }
4662
4663 static void __exit bttv_cleanup_module(void)
4664 {
4665         pci_unregister_driver(&bttv_pci_driver);
4666         bus_unregister(&bttv_sub_bus_type);
4667 }
4668
4669 module_init(bttv_init_module);
4670 module_exit(bttv_cleanup_module);
4671
4672 /*
4673  * Local variables:
4674  * c-basic-offset: 8
4675  * End:
4676  */