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

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