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