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