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_g_crop                  = bttv_g_crop,
3393         .vidioc_s_crop                  = bttv_s_crop,
3394         .vidioc_g_fbuf                  = bttv_g_fbuf,
3395         .vidioc_s_fbuf                  = bttv_s_fbuf,
3396         .vidioc_overlay                 = bttv_overlay,
3397         .vidioc_g_priority              = bttv_g_priority,
3398         .vidioc_s_priority              = bttv_s_priority,
3399         .vidioc_g_parm                  = bttv_g_parm,
3400         .vidioc_g_frequency             = bttv_g_frequency,
3401         .vidioc_s_frequency             = bttv_s_frequency,
3402         .vidioc_log_status              = bttv_log_status,
3403         .vidioc_querystd                = bttv_querystd,
3404 #ifdef CONFIG_VIDEO_ADV_DEBUG
3405         .vidioc_g_register              = bttv_g_register,
3406         .vidioc_s_register              = bttv_s_register,
3407 #endif
3408         .tvnorms                        = BTTV_NORMS,
3409         .current_norm                   = V4L2_STD_PAL,
3410 };
3411
3412 /* ----------------------------------------------------------------------- */
3413 /* radio interface                                                         */
3414
3415 static int radio_open(struct inode *inode, struct file *file)
3416 {
3417         int minor = iminor(inode);
3418         struct bttv *btv = NULL;
3419         unsigned int i;
3420
3421         dprintk("bttv: open minor=%d\n",minor);
3422
3423         for (i = 0; i < bttv_num; i++) {
3424                 if (bttvs[i].radio_dev->minor == minor) {
3425                         btv = &bttvs[i];
3426                         break;
3427                 }
3428         }
3429         if (NULL == btv)
3430                 return -ENODEV;
3431
3432         dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3433         mutex_lock(&btv->lock);
3434
3435         btv->radio_user++;
3436
3437         file->private_data = btv;
3438
3439         bttv_call_i2c_clients(btv,AUDC_SET_RADIO,NULL);
3440         audio_input(btv,TVAUDIO_INPUT_RADIO);
3441
3442         mutex_unlock(&btv->lock);
3443         return 0;
3444 }
3445
3446 static int radio_release(struct inode *inode, struct file *file)
3447 {
3448         struct bttv *btv = file->private_data;
3449         struct rds_command cmd;
3450
3451         btv->radio_user--;
3452
3453         bttv_call_i2c_clients(btv, RDS_CMD_CLOSE, &cmd);
3454
3455         return 0;
3456 }
3457
3458 static int radio_querycap(struct file *file, void *priv,
3459                                         struct v4l2_capability *cap)
3460 {
3461         struct bttv_fh *fh = priv;
3462         struct bttv *btv = fh->btv;
3463
3464         strcpy(cap->driver, "bttv");
3465         strlcpy(cap->card, btv->radio_dev->name, sizeof(cap->card));
3466         sprintf(cap->bus_info, "PCI:%s", pci_name(btv->c.pci));
3467         cap->version = BTTV_VERSION_CODE;
3468         cap->capabilities = V4L2_CAP_TUNER;
3469
3470         return 0;
3471 }
3472
3473 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3474 {
3475         struct bttv_fh *fh = priv;
3476         struct bttv *btv = fh->btv;
3477
3478         if (UNSET == bttv_tvcards[btv->c.type].tuner)
3479                 return -EINVAL;
3480         if (0 != t->index)
3481                 return -EINVAL;
3482         mutex_lock(&btv->lock);
3483         memset(t, 0, sizeof(*t));
3484         strcpy(t->name, "Radio");
3485         t->type = V4L2_TUNER_RADIO;
3486
3487         bttv_call_i2c_clients(btv, VIDIOC_G_TUNER, t);
3488
3489         if (btv->audio_mode_gpio)
3490                 btv->audio_mode_gpio(btv, t, 0);
3491
3492         mutex_unlock(&btv->lock);
3493
3494         return 0;
3495 }
3496
3497 static int radio_enum_input(struct file *file, void *priv,
3498                                 struct v4l2_input *i)
3499 {
3500         if (i->index != 0)
3501                 return -EINVAL;
3502
3503         strcpy(i->name, "Radio");
3504          i->type = V4L2_INPUT_TYPE_TUNER;
3505
3506         return 0;
3507 }
3508
3509 static int radio_g_audio(struct file *file, void *priv,
3510                                         struct v4l2_audio *a)
3511 {
3512         memset(a, 0, sizeof(*a));
3513         strcpy(a->name, "Radio");
3514         return 0;
3515 }
3516
3517 static int radio_s_tuner(struct file *file, void *priv,
3518                                         struct v4l2_tuner *t)
3519 {
3520         struct bttv_fh *fh = priv;
3521         struct bttv *btv = fh->btv;
3522
3523         if (0 != t->index)
3524                 return -EINVAL;
3525
3526         bttv_call_i2c_clients(btv, VIDIOC_G_TUNER, t);
3527         return 0;
3528 }
3529
3530 static int radio_s_audio(struct file *file, void *priv,
3531                                         struct v4l2_audio *a)
3532 {
3533         return 0;
3534 }
3535
3536 static int radio_s_input(struct file *filp, void *priv, unsigned int i)
3537 {
3538         return 0;
3539 }
3540
3541 static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
3542 {
3543         return 0;
3544 }
3545
3546 static int radio_queryctrl(struct file *file, void *priv,
3547                                         struct v4l2_queryctrl *c)
3548 {
3549         const struct v4l2_queryctrl *ctrl;
3550
3551         if (c->id <  V4L2_CID_BASE ||
3552                         c->id >= V4L2_CID_LASTP1)
3553                 return -EINVAL;
3554
3555         if (c->id == V4L2_CID_AUDIO_MUTE) {
3556                 ctrl = ctrl_by_id(c->id);
3557                 *c = *ctrl;
3558         } else
3559                 *c = no_ctl;
3560
3561         return 0;
3562 }
3563
3564 static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
3565 {
3566         *i = 0;
3567         return 0;
3568 }
3569
3570 static ssize_t radio_read(struct file *file, char __user *data,
3571                          size_t count, loff_t *ppos)
3572 {
3573         struct bttv    *btv = file->private_data;
3574         struct rds_command cmd;
3575         cmd.block_count = count/3;
3576         cmd.buffer = data;
3577         cmd.instance = file;
3578         cmd.result = -ENODEV;
3579
3580         bttv_call_i2c_clients(btv, RDS_CMD_READ, &cmd);
3581
3582         return cmd.result;
3583 }
3584
3585 static unsigned int radio_poll(struct file *file, poll_table *wait)
3586 {
3587         struct bttv    *btv = file->private_data;
3588         struct rds_command cmd;
3589         cmd.instance = file;
3590         cmd.event_list = wait;
3591         cmd.result = -ENODEV;
3592         bttv_call_i2c_clients(btv, RDS_CMD_POLL, &cmd);
3593
3594         return cmd.result;
3595 }
3596
3597 static const struct file_operations radio_fops =
3598 {
3599         .owner    = THIS_MODULE,
3600         .open     = radio_open,
3601         .read     = radio_read,
3602         .release  = radio_release,
3603         .ioctl    = video_ioctl2,
3604         .llseek   = no_llseek,
3605         .poll     = radio_poll,
3606 };
3607
3608 static struct video_device radio_template =
3609 {
3610         .fops     = &radio_fops,
3611         .minor    = -1,
3612         .vidioc_querycap        = radio_querycap,
3613         .vidioc_g_tuner         = radio_g_tuner,
3614         .vidioc_enum_input      = radio_enum_input,
3615         .vidioc_g_audio         = radio_g_audio,
3616         .vidioc_s_tuner         = radio_s_tuner,
3617         .vidioc_s_audio         = radio_s_audio,
3618         .vidioc_s_input         = radio_s_input,
3619         .vidioc_s_std           = radio_s_std,
3620         .vidioc_queryctrl       = radio_queryctrl,
3621         .vidioc_g_input         = radio_g_input,
3622         .vidioc_g_ctrl          = bttv_g_ctrl,
3623         .vidioc_s_ctrl          = bttv_s_ctrl,
3624         .vidioc_g_frequency     = bttv_g_frequency,
3625         .vidioc_s_frequency     = bttv_s_frequency,
3626 };
3627
3628 /* ----------------------------------------------------------------------- */
3629 /* some debug code                                                         */
3630
3631 static int bttv_risc_decode(u32 risc)
3632 {
3633         static char *instr[16] = {
3634                 [ BT848_RISC_WRITE     >> 28 ] = "write",
3635                 [ BT848_RISC_SKIP      >> 28 ] = "skip",
3636                 [ BT848_RISC_WRITEC    >> 28 ] = "writec",
3637                 [ BT848_RISC_JUMP      >> 28 ] = "jump",
3638                 [ BT848_RISC_SYNC      >> 28 ] = "sync",
3639                 [ BT848_RISC_WRITE123  >> 28 ] = "write123",
3640                 [ BT848_RISC_SKIP123   >> 28 ] = "skip123",
3641                 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3642         };
3643         static int incr[16] = {
3644                 [ BT848_RISC_WRITE     >> 28 ] = 2,
3645                 [ BT848_RISC_JUMP      >> 28 ] = 2,
3646                 [ BT848_RISC_SYNC      >> 28 ] = 2,
3647                 [ BT848_RISC_WRITE123  >> 28 ] = 5,
3648                 [ BT848_RISC_SKIP123   >> 28 ] = 2,
3649                 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3650         };
3651         static char *bits[] = {
3652                 "be0",  "be1",  "be2",  "be3/resync",
3653                 "set0", "set1", "set2", "set3",
3654                 "clr0", "clr1", "clr2", "clr3",
3655                 "irq",  "res",  "eol",  "sol",
3656         };
3657         int i;
3658
3659         printk("0x%08x [ %s", risc,
3660                instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3661         for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3662                 if (risc & (1 << (i + 12)))
3663                         printk(" %s",bits[i]);
3664         printk(" count=%d ]\n", risc & 0xfff);
3665         return incr[risc >> 28] ? incr[risc >> 28] : 1;
3666 }
3667
3668 static void bttv_risc_disasm(struct bttv *btv,
3669                              struct btcx_riscmem *risc)
3670 {
3671         unsigned int i,j,n;
3672
3673         printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3674                btv->c.name, risc->cpu, (unsigned long)risc->dma);
3675         for (i = 0; i < (risc->size >> 2); i += n) {
3676                 printk("%s:   0x%lx: ", btv->c.name,
3677                        (unsigned long)(risc->dma + (i<<2)));
3678                 n = bttv_risc_decode(risc->cpu[i]);
3679                 for (j = 1; j < n; j++)
3680                         printk("%s:   0x%lx: 0x%08x [ arg #%d ]\n",
3681                                btv->c.name, (unsigned long)(risc->dma + ((i+j)<<2)),
3682                                risc->cpu[i+j], j);
3683                 if (0 == risc->cpu[i])
3684                         break;
3685         }
3686 }
3687
3688 static void bttv_print_riscaddr(struct bttv *btv)
3689 {
3690         printk("  main: %08Lx\n",
3691                (unsigned long long)btv->main.dma);
3692         printk("  vbi : o=%08Lx e=%08Lx\n",
3693                btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3694                btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3695         printk("  cap : o=%08Lx e=%08Lx\n",
3696                btv->curr.top    ? (unsigned long long)btv->curr.top->top.dma : 0,
3697                btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3698         printk("  scr : o=%08Lx e=%08Lx\n",
3699                btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3700                btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3701         bttv_risc_disasm(btv, &btv->main);
3702 }
3703
3704 /* ----------------------------------------------------------------------- */
3705 /* irq handler                                                             */
3706
3707 static char *irq_name[] = {
3708         "FMTCHG",  // format change detected (525 vs. 625)
3709         "VSYNC",   // vertical sync (new field)
3710         "HSYNC",   // horizontal sync
3711         "OFLOW",   // chroma/luma AGC overflow
3712         "HLOCK",   // horizontal lock changed
3713         "VPRES",   // video presence changed
3714         "6", "7",
3715         "I2CDONE", // hw irc operation finished
3716         "GPINT",   // gpio port triggered irq
3717         "10",
3718         "RISCI",   // risc instruction triggered irq
3719         "FBUS",    // pixel data fifo dropped data (high pci bus latencies)
3720         "FTRGT",   // pixel data fifo overrun
3721         "FDSR",    // fifo data stream resyncronisation
3722         "PPERR",   // parity error (data transfer)
3723         "RIPERR",  // parity error (read risc instructions)
3724         "PABORT",  // pci abort
3725         "OCERR",   // risc instruction error
3726         "SCERR",   // syncronisation error
3727 };
3728
3729 static void bttv_print_irqbits(u32 print, u32 mark)
3730 {
3731         unsigned int i;
3732
3733         printk("bits:");
3734         for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3735                 if (print & (1 << i))
3736                         printk(" %s",irq_name[i]);
3737                 if (mark & (1 << i))
3738                         printk("*");
3739         }
3740 }
3741
3742 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3743 {
3744         printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3745                btv->c.nr,
3746                (unsigned long)btv->main.dma,
3747                (unsigned long)btv->main.cpu[RISC_SLOT_O_VBI+1],
3748                (unsigned long)btv->main.cpu[RISC_SLOT_O_FIELD+1],
3749                (unsigned long)rc);
3750
3751         if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3752                 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3753                        "Ok, then this is harmless, don't worry ;)\n",
3754                        btv->c.nr);
3755                 return;
3756         }
3757         printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3758                btv->c.nr);
3759         printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3760                btv->c.nr);
3761         dump_stack();
3762 }
3763
3764 static int
3765 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3766 {
3767         struct bttv_buffer *item;
3768
3769         memset(set,0,sizeof(*set));
3770
3771         /* capture request ? */
3772         if (!list_empty(&btv->capture)) {
3773                 set->frame_irq = 1;
3774                 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3775                 if (V4L2_FIELD_HAS_TOP(item->vb.field))
3776                         set->top    = item;
3777                 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3778                         set->bottom = item;
3779
3780                 /* capture request for other field ? */
3781                 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3782                     (item->vb.queue.next != &btv->capture)) {
3783                         item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3784                         if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3785                                 if (NULL == set->top &&
3786                                     V4L2_FIELD_TOP == item->vb.field) {
3787                                         set->top = item;
3788                                 }
3789                                 if (NULL == set->bottom &&
3790                                     V4L2_FIELD_BOTTOM == item->vb.field) {
3791                                         set->bottom = item;
3792                                 }
3793                                 if (NULL != set->top  &&  NULL != set->bottom)
3794                                         set->top_irq = 2;
3795                         }
3796                 }
3797         }
3798
3799         /* screen overlay ? */
3800         if (NULL != btv->screen) {
3801                 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3802                         if (NULL == set->top && NULL == set->bottom) {
3803                                 set->top    = btv->screen;
3804                                 set->bottom = btv->screen;
3805                         }
3806                 } else {
3807                         if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3808                             NULL == set->top) {
3809                                 set->top = btv->screen;
3810                         }
3811                         if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3812                             NULL == set->bottom) {
3813                                 set->bottom = btv->screen;
3814                         }
3815                 }
3816         }
3817
3818         dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3819                 btv->c.nr,set->top, set->bottom,
3820                 btv->screen,set->frame_irq,set->top_irq);
3821         return 0;
3822 }
3823
3824 static void
3825 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3826                       struct bttv_buffer_set *curr, unsigned int state)
3827 {
3828         struct timeval ts;
3829
3830         do_gettimeofday(&ts);
3831
3832         if (wakeup->top == wakeup->bottom) {
3833                 if (NULL != wakeup->top && curr->top != wakeup->top) {
3834                         if (irq_debug > 1)
3835                                 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
3836                         wakeup->top->vb.ts = ts;
3837                         wakeup->top->vb.field_count = btv->field_count;
3838                         wakeup->top->vb.state = state;
3839                         wake_up(&wakeup->top->vb.done);
3840                 }
3841         } else {
3842                 if (NULL != wakeup->top && curr->top != wakeup->top) {
3843                         if (irq_debug > 1)
3844                                 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
3845                         wakeup->top->vb.ts = ts;
3846                         wakeup->top->vb.field_count = btv->field_count;
3847                         wakeup->top->vb.state = state;
3848                         wake_up(&wakeup->top->vb.done);
3849                 }
3850                 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3851                         if (irq_debug > 1)
3852                                 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
3853                         wakeup->bottom->vb.ts = ts;
3854                         wakeup->bottom->vb.field_count = btv->field_count;
3855                         wakeup->bottom->vb.state = state;
3856                         wake_up(&wakeup->bottom->vb.done);
3857                 }
3858         }
3859 }
3860
3861 static void
3862 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3863                     unsigned int state)
3864 {
3865         struct timeval ts;
3866
3867         if (NULL == wakeup)
3868                 return;
3869
3870         do_gettimeofday(&ts);
3871         wakeup->vb.ts = ts;
3872         wakeup->vb.field_count = btv->field_count;
3873         wakeup->vb.state = state;
3874         wake_up(&wakeup->vb.done);
3875 }
3876
3877 static void bttv_irq_timeout(unsigned long data)
3878 {
3879         struct bttv *btv = (struct bttv *)data;
3880         struct bttv_buffer_set old,new;
3881         struct bttv_buffer *ovbi;
3882         struct bttv_buffer *item;
3883         unsigned long flags;
3884
3885         if (bttv_verbose) {
3886                 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3887                        btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3888                        btread(BT848_RISC_COUNT));
3889                 bttv_print_irqbits(btread(BT848_INT_STAT),0);
3890                 printk("\n");
3891         }
3892
3893         spin_lock_irqsave(&btv->s_lock,flags);
3894
3895         /* deactivate stuff */
3896         memset(&new,0,sizeof(new));
3897         old  = btv->curr;
3898         ovbi = btv->cvbi;
3899         btv->curr = new;
3900         btv->cvbi = NULL;
3901         btv->loop_irq = 0;
3902         bttv_buffer_activate_video(btv, &new);
3903         bttv_buffer_activate_vbi(btv,   NULL);
3904         bttv_set_dma(btv, 0);
3905
3906         /* wake up */
3907         bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
3908         bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
3909
3910         /* cancel all outstanding capture / vbi requests */
3911         while (!list_empty(&btv->capture)) {
3912                 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3913                 list_del(&item->vb.queue);
3914                 item->vb.state = VIDEOBUF_ERROR;
3915                 wake_up(&item->vb.done);
3916         }
3917         while (!list_empty(&btv->vcapture)) {
3918                 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3919                 list_del(&item->vb.queue);
3920                 item->vb.state = VIDEOBUF_ERROR;
3921                 wake_up(&item->vb.done);
3922         }
3923
3924         btv->errors++;
3925         spin_unlock_irqrestore(&btv->s_lock,flags);
3926 }
3927
3928 static void
3929 bttv_irq_wakeup_top(struct bttv *btv)
3930 {
3931         struct bttv_buffer *wakeup = btv->curr.top;
3932
3933         if (NULL == wakeup)
3934                 return;
3935
3936         spin_lock(&btv->s_lock);
3937         btv->curr.top_irq = 0;
3938         btv->curr.top = NULL;
3939         bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3940
3941         do_gettimeofday(&wakeup->vb.ts);
3942         wakeup->vb.field_count = btv->field_count;
3943         wakeup->vb.state = VIDEOBUF_DONE;
3944         wake_up(&wakeup->vb.done);
3945         spin_unlock(&btv->s_lock);
3946 }
3947
3948 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
3949 {
3950         if (rc < risc->dma)
3951                 return 0;
3952         if (rc > risc->dma + risc->size)
3953                 return 0;
3954         return 1;
3955 }
3956
3957 static void
3958 bttv_irq_switch_video(struct bttv *btv)
3959 {
3960         struct bttv_buffer_set new;
3961         struct bttv_buffer_set old;
3962         dma_addr_t rc;
3963
3964         spin_lock(&btv->s_lock);
3965
3966         /* new buffer set */
3967         bttv_irq_next_video(btv, &new);
3968         rc = btread(BT848_RISC_COUNT);
3969         if ((btv->curr.top    && is_active(&btv->curr.top->top,       rc)) ||
3970             (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
3971                 btv->framedrop++;
3972                 if (debug_latency)
3973                         bttv_irq_debug_low_latency(btv, rc);
3974                 spin_unlock(&btv->s_lock);
3975                 return;
3976         }
3977
3978         /* switch over */
3979         old = btv->curr;
3980         btv->curr = new;
3981         btv->loop_irq &= ~1;
3982         bttv_buffer_activate_video(btv, &new);
3983         bttv_set_dma(btv, 0);
3984
3985         /* switch input */
3986         if (UNSET != btv->new_input) {
3987                 video_mux(btv,btv->new_input);
3988                 btv->new_input = UNSET;
3989         }
3990
3991         /* wake up finished buffers */
3992         bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
3993         spin_unlock(&btv->s_lock);
3994 }
3995
3996 static void
3997 bttv_irq_switch_vbi(struct bttv *btv)
3998 {
3999         struct bttv_buffer *new = NULL;
4000         struct bttv_buffer *old;
4001         u32 rc;
4002
4003         spin_lock(&btv->s_lock);
4004
4005         if (!list_empty(&btv->vcapture))
4006                 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4007         old = btv->cvbi;
4008
4009         rc = btread(BT848_RISC_COUNT);
4010         if (NULL != old && (is_active(&old->top,    rc) ||
4011                             is_active(&old->bottom, rc))) {
4012                 btv->framedrop++;
4013                 if (debug_latency)
4014                         bttv_irq_debug_low_latency(btv, rc);
4015                 spin_unlock(&btv->s_lock);
4016                 return;
4017         }
4018
4019         /* switch */
4020         btv->cvbi = new;
4021         btv->loop_irq &= ~4;
4022         bttv_buffer_activate_vbi(btv, new);
4023         bttv_set_dma(btv, 0);
4024
4025         bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
4026         spin_unlock(&btv->s_lock);
4027 }
4028
4029 static irqreturn_t bttv_irq(int irq, void *dev_id)
4030 {
4031         u32 stat,astat;
4032         u32 dstat;
4033         int count;
4034         struct bttv *btv;
4035         int handled = 0;
4036
4037         btv=(struct bttv *)dev_id;
4038
4039         if (btv->custom_irq)
4040                 handled = btv->custom_irq(btv);
4041
4042         count=0;
4043         while (1) {
4044                 /* get/clear interrupt status bits */
4045                 stat=btread(BT848_INT_STAT);
4046                 astat=stat&btread(BT848_INT_MASK);
4047                 if (!astat)
4048                         break;
4049                 handled = 1;
4050                 btwrite(stat,BT848_INT_STAT);
4051
4052                 /* get device status bits */
4053                 dstat=btread(BT848_DSTATUS);
4054
4055                 if (irq_debug) {
4056                         printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
4057                                "riscs=%x, riscc=%08x, ",
4058                                btv->c.nr, count, btv->field_count,
4059                                stat>>28, btread(BT848_RISC_COUNT));
4060                         bttv_print_irqbits(stat,astat);
4061                         if (stat & BT848_INT_HLOCK)
4062                                 printk("   HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
4063                                        ? "yes" : "no");
4064                         if (stat & BT848_INT_VPRES)
4065                                 printk("   PRES => %s", (dstat & BT848_DSTATUS_PRES)
4066                                        ? "yes" : "no");
4067                         if (stat & BT848_INT_FMTCHG)
4068                                 printk("   NUML => %s", (dstat & BT848_DSTATUS_NUML)
4069                                        ? "625" : "525");
4070                         printk("\n");
4071                 }
4072
4073                 if (astat&BT848_INT_VSYNC)
4074                         btv->field_count++;
4075
4076                 if ((astat & BT848_INT_GPINT) && btv->remote) {
4077                         wake_up(&btv->gpioq);
4078                         bttv_input_irq(btv);
4079                 }
4080
4081                 if (astat & BT848_INT_I2CDONE) {
4082                         btv->i2c_done = stat;
4083                         wake_up(&btv->i2c_queue);
4084                 }
4085
4086                 if ((astat & BT848_INT_RISCI)  &&  (stat & (4<<28)))
4087                         bttv_irq_switch_vbi(btv);
4088
4089                 if ((astat & BT848_INT_RISCI)  &&  (stat & (2<<28)))
4090                         bttv_irq_wakeup_top(btv);
4091
4092                 if ((astat & BT848_INT_RISCI)  &&  (stat & (1<<28)))
4093                         bttv_irq_switch_video(btv);
4094
4095                 if ((astat & BT848_INT_HLOCK)  &&  btv->opt_automute)
4096                         audio_mute(btv, btv->mute);  /* trigger automute */
4097
4098                 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
4099                         printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
4100                                (astat & BT848_INT_SCERR) ? "SCERR" : "",
4101                                (astat & BT848_INT_OCERR) ? "OCERR" : "",
4102                                btread(BT848_RISC_COUNT));
4103                         bttv_print_irqbits(stat,astat);
4104                         printk("\n");
4105                         if (bttv_debug)
4106                                 bttv_print_riscaddr(btv);
4107                 }
4108                 if (fdsr && astat & BT848_INT_FDSR) {
4109                         printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
4110                                btv->c.nr,btread(BT848_RISC_COUNT));
4111                         if (bttv_debug)
4112                                 bttv_print_riscaddr(btv);
4113                 }
4114
4115                 count++;
4116                 if (count > 4) {
4117
4118                         if (count > 8 || !(astat & BT848_INT_GPINT)) {
4119                                 btwrite(0, BT848_INT_MASK);
4120
4121                                 printk(KERN_ERR
4122                                            "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
4123                         } else {
4124                                 printk(KERN_ERR
4125                                            "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
4126
4127                                 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
4128                                                 BT848_INT_MASK);
4129                         };
4130
4131                         bttv_print_irqbits(stat,astat);
4132
4133                         printk("]\n");
4134                 }
4135         }
4136         btv->irq_total++;
4137         if (handled)
4138                 btv->irq_me++;
4139         return IRQ_RETVAL(handled);
4140 }
4141
4142
4143 /* ----------------------------------------------------------------------- */
4144 /* initialitation                                                          */
4145
4146 static struct video_device *vdev_init(struct bttv *btv,
4147                                       const struct video_device *template,
4148                                       const char *type_name,
4149                                       const int type)
4150 {
4151         struct video_device *vfd;
4152
4153         vfd = video_device_alloc();
4154         if (NULL == vfd)
4155                 return NULL;
4156         *vfd = *template;
4157         vfd->minor   = -1;
4158         vfd->dev     = &btv->c.pci->dev;
4159         vfd->release = video_device_release;
4160         vfd->type    = type;
4161         snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
4162                  btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
4163                  type_name, bttv_tvcards[btv->c.type].name);
4164         return vfd;
4165 }
4166
4167 static void bttv_unregister_video(struct bttv *btv)
4168 {
4169         if (btv->video_dev) {
4170                 if (-1 != btv->video_dev->minor)
4171                         video_unregister_device(btv->video_dev);
4172                 else
4173                         video_device_release(btv->video_dev);
4174                 btv->video_dev = NULL;
4175         }
4176         if (btv->vbi_dev) {
4177                 if (-1 != btv->vbi_dev->minor)
4178                         video_unregister_device(btv->vbi_dev);
4179                 else
4180                         video_device_release(btv->vbi_dev);
4181                 btv->vbi_dev = NULL;
4182         }
4183         if (btv->radio_dev) {
4184                 if (-1 != btv->radio_dev->minor)
4185                         video_unregister_device(btv->radio_dev);
4186                 else
4187                         video_device_release(btv->radio_dev);
4188                 btv->radio_dev = NULL;
4189         }
4190 }
4191
4192 /* register video4linux devices */
4193 static int __devinit bttv_register_video(struct bttv *btv)
4194 {
4195         int video_type = VID_TYPE_CAPTURE |
4196                          VID_TYPE_TUNER   |
4197                          VID_TYPE_CLIPPING|
4198                          VID_TYPE_SCALES;
4199
4200         if (no_overlay <= 0) {
4201                 bttv_video_template.type |= VID_TYPE_OVERLAY;
4202         } else {
4203                 printk("bttv: Overlay support disabled.\n");
4204         }
4205
4206         /* video */
4207         btv->video_dev = vdev_init(btv, &bttv_video_template,
4208                                    "video", video_type);
4209
4210         if (NULL == btv->video_dev)
4211                 goto err;
4212         if (video_register_device(btv->video_dev,VFL_TYPE_GRABBER,video_nr)<0)
4213                 goto err;
4214         printk(KERN_INFO "bttv%d: registered device video%d\n",
4215                btv->c.nr,btv->video_dev->minor & 0x1f);
4216         if (device_create_file(&btv->video_dev->class_dev,
4217                                      &dev_attr_card)<0) {
4218                 printk(KERN_ERR "bttv%d: device_create_file 'card' "
4219                        "failed\n", btv->c.nr);
4220                 goto err;
4221         }
4222
4223         /* vbi */
4224         btv->vbi_dev = vdev_init(btv, &bttv_video_template,
4225                                  "vbi", VID_TYPE_TUNER | VID_TYPE_TELETEXT);
4226
4227         if (NULL == btv->vbi_dev)
4228                 goto err;
4229         if (video_register_device(btv->vbi_dev,VFL_TYPE_VBI,vbi_nr)<0)
4230                 goto err;
4231         printk(KERN_INFO "bttv%d: registered device vbi%d\n",
4232                btv->c.nr,btv->vbi_dev->minor & 0x1f);
4233
4234         if (!btv->has_radio)
4235                 return 0;
4236         /* radio */
4237         btv->radio_dev = vdev_init(btv, &radio_template,
4238                                    "radio", VID_TYPE_TUNER);
4239         if (NULL == btv->radio_dev)
4240                 goto err;
4241         if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,radio_nr)<0)
4242                 goto err;
4243         printk(KERN_INFO "bttv%d: registered device radio%d\n",
4244                btv->c.nr,btv->radio_dev->minor & 0x1f);
4245
4246         /* all done */
4247         return 0;
4248
4249  err:
4250         bttv_unregister_video(btv);
4251         return -1;
4252 }
4253
4254
4255 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
4256 /* response on cards with no firmware is not enabled by OF */
4257 static void pci_set_command(struct pci_dev *dev)
4258 {
4259 #if defined(__powerpc__)
4260         unsigned int cmd;
4261
4262         pci_read_config_dword(dev, PCI_COMMAND, &cmd);
4263         cmd = (cmd | PCI_COMMAND_MEMORY );
4264         pci_write_config_dword(dev, PCI_COMMAND, cmd);
4265 #endif
4266 }
4267
4268 static int __devinit bttv_probe(struct pci_dev *dev,
4269                                 const struct pci_device_id *pci_id)
4270 {
4271         int result;
4272         unsigned char lat;
4273         struct bttv *btv;
4274
4275         if (bttv_num == BTTV_MAX)
4276                 return -ENOMEM;
4277         printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
4278         btv=&bttvs[bttv_num];
4279         memset(btv,0,sizeof(*btv));
4280         btv->c.nr  = bttv_num;
4281         sprintf(btv->c.name,"bttv%d",btv->c.nr);
4282
4283         /* initialize structs / fill in defaults */
4284         mutex_init(&btv->lock);
4285         spin_lock_init(&btv->s_lock);
4286         spin_lock_init(&btv->gpio_lock);
4287         init_waitqueue_head(&btv->gpioq);
4288         init_waitqueue_head(&btv->i2c_queue);
4289         INIT_LIST_HEAD(&btv->c.subs);
4290         INIT_LIST_HEAD(&btv->capture);
4291         INIT_LIST_HEAD(&btv->vcapture);
4292         v4l2_prio_init(&btv->prio);
4293
4294         init_timer(&btv->timeout);
4295         btv->timeout.function = bttv_irq_timeout;
4296         btv->timeout.data     = (unsigned long)btv;
4297
4298         btv->i2c_rc = -1;
4299         btv->tuner_type  = UNSET;
4300         btv->new_input   = UNSET;
4301         btv->has_radio=radio[btv->c.nr];
4302
4303         /* pci stuff (init, get irq/mmio, ... */
4304         btv->c.pci = dev;
4305         btv->id  = dev->device;
4306         if (pci_enable_device(dev)) {
4307                 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4308                        btv->c.nr);
4309                 return -EIO;
4310         }
4311         if (pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
4312                 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
4313                        btv->c.nr);
4314                 return -EIO;
4315         }
4316         if (!request_mem_region(pci_resource_start(dev,0),
4317                                 pci_resource_len(dev,0),
4318                                 btv->c.name)) {
4319                 printk(KERN_WARNING "bttv%d: can't request iomem (0x%llx).\n",
4320                        btv->c.nr,
4321                        (unsigned long long)pci_resource_start(dev,0));
4322                 return -EBUSY;
4323         }
4324         pci_set_master(dev);
4325         pci_set_command(dev);
4326         pci_set_drvdata(dev,btv);
4327
4328         pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
4329         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4330         printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
4331                bttv_num,btv->id, btv->revision, pci_name(dev));
4332         printk("irq: %d, latency: %d, mmio: 0x%llx\n",
4333                btv->c.pci->irq, lat,
4334                (unsigned long long)pci_resource_start(dev,0));
4335         schedule();
4336
4337         btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4338         if (NULL == btv->bt848_mmio) {
4339                 printk("bttv%d: ioremap() failed\n", btv->c.nr);
4340                 result = -EIO;
4341                 goto fail1;
4342         }
4343
4344         /* identify card */
4345         bttv_idcard(btv);
4346
4347         /* disable irqs, register irq handler */
4348         btwrite(0, BT848_INT_MASK);
4349         result = request_irq(btv->c.pci->irq, bttv_irq,
4350                              IRQF_SHARED | IRQF_DISABLED,btv->c.name,(void *)btv);
4351         if (result < 0) {
4352                 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
4353                        bttv_num,btv->c.pci->irq);
4354                 goto fail1;
4355         }
4356
4357         if (0 != bttv_handle_chipset(btv)) {
4358                 result = -EIO;
4359                 goto fail2;
4360         }
4361
4362         /* init options from insmod args */
4363         btv->opt_combfilter = combfilter;
4364         btv->opt_lumafilter = lumafilter;
4365         btv->opt_automute   = automute;
4366         btv->opt_chroma_agc = chroma_agc;
4367         btv->opt_adc_crush  = adc_crush;
4368         btv->opt_vcr_hack   = vcr_hack;
4369         btv->opt_whitecrush_upper  = whitecrush_upper;
4370         btv->opt_whitecrush_lower  = whitecrush_lower;
4371         btv->opt_uv_ratio   = uv_ratio;
4372         btv->opt_full_luma_range   = full_luma_range;
4373         btv->opt_coring     = coring;
4374
4375         /* fill struct bttv with some useful defaults */
4376         btv->init.btv         = btv;
4377         btv->init.ov.w.width  = 320;
4378         btv->init.ov.w.height = 240;
4379         btv->init.fmt         = format_by_fourcc(V4L2_PIX_FMT_BGR24);
4380         btv->init.width       = 320;
4381         btv->init.height      = 240;
4382         btv->input = 0;
4383
4384         /* initialize hardware */
4385         if (bttv_gpio)
4386                 bttv_gpio_tracking(btv,"pre-init");
4387
4388         bttv_risc_init_main(btv);
4389         init_bt848(btv);
4390
4391         /* gpio */
4392         btwrite(0x00, BT848_GPIO_REG_INP);
4393         btwrite(0x00, BT848_GPIO_OUT_EN);
4394         if (bttv_verbose)
4395                 bttv_gpio_tracking(btv,"init");
4396
4397         /* needs to be done before i2c is registered */
4398         bttv_init_card1(btv);
4399
4400         /* register i2c + gpio */
4401         init_bttv_i2c(btv);
4402
4403         /* some card-specific stuff (needs working i2c) */
4404         bttv_init_card2(btv);
4405         init_irqreg(btv);
4406
4407         /* register video4linux + input */
4408         if (!bttv_tvcards[btv->c.type].no_video) {
4409                 bttv_register_video(btv);
4410                 bt848_bright(btv,32768);
4411                 bt848_contrast(btv,32768);
4412                 bt848_hue(btv,32768);
4413                 bt848_sat(btv,32768);
4414                 audio_mute(btv, 1);
4415                 set_input(btv, 0, btv->tvnorm);
4416                 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4417                 btv->crop[1] = btv->crop[0]; /* current = default */
4418                 disclaim_vbi_lines(btv);
4419                 disclaim_video_lines(btv);
4420         }
4421
4422         /* add subdevices and autoload dvb-bt8xx if needed */
4423         if (bttv_tvcards[btv->c.type].has_dvb) {
4424                 bttv_sub_add_device(&btv->c, "dvb");
4425                 request_modules(btv);
4426         }
4427
4428         bttv_input_init(btv);
4429
4430         /* everything is fine */
4431         bttv_num++;
4432         return 0;
4433
4434  fail2:
4435         free_irq(btv->c.pci->irq,btv);
4436
4437  fail1:
4438         if (btv->bt848_mmio)
4439                 iounmap(btv->bt848_mmio);
4440         release_mem_region(pci_resource_start(btv->c.pci,0),
4441                            pci_resource_len(btv->c.pci,0));
4442         pci_set_drvdata(dev,NULL);
4443         return result;
4444 }
4445
4446 static void __devexit bttv_remove(struct pci_dev *pci_dev)
4447 {
4448         struct bttv *btv = pci_get_drvdata(pci_dev);
4449
4450         if (bttv_verbose)
4451                 printk("bttv%d: unloading\n",btv->c.nr);
4452
4453         /* shutdown everything (DMA+IRQs) */
4454         btand(~15, BT848_GPIO_DMA_CTL);
4455         btwrite(0, BT848_INT_MASK);
4456         btwrite(~0x0, BT848_INT_STAT);
4457         btwrite(0x0, BT848_GPIO_OUT_EN);
4458         if (bttv_gpio)
4459                 bttv_gpio_tracking(btv,"cleanup");
4460
4461         /* tell gpio modules we are leaving ... */
4462         btv->shutdown=1;
4463         wake_up(&btv->gpioq);
4464         bttv_input_fini(btv);
4465         bttv_sub_del_devices(&btv->c);
4466
4467         /* unregister i2c_bus + input */
4468         fini_bttv_i2c(btv);
4469
4470         /* unregister video4linux */
4471         bttv_unregister_video(btv);
4472
4473         /* free allocated memory */
4474         btcx_riscmem_free(btv->c.pci,&btv->main);
4475
4476         /* free ressources */
4477         free_irq(btv->c.pci->irq,btv);
4478         iounmap(btv->bt848_mmio);
4479         release_mem_region(pci_resource_start(btv->c.pci,0),
4480                            pci_resource_len(btv->c.pci,0));
4481
4482         pci_set_drvdata(pci_dev, NULL);
4483         return;
4484 }
4485
4486 #ifdef CONFIG_PM
4487 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4488 {
4489         struct bttv *btv = pci_get_drvdata(pci_dev);
4490         struct bttv_buffer_set idle;
4491         unsigned long flags;
4492
4493         dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
4494
4495         /* stop dma + irqs */
4496         spin_lock_irqsave(&btv->s_lock,flags);
4497         memset(&idle, 0, sizeof(idle));
4498         btv->state.video = btv->curr;
4499         btv->state.vbi   = btv->cvbi;
4500         btv->state.loop_irq = btv->loop_irq;
4501         btv->curr = idle;
4502         btv->loop_irq = 0;
4503         bttv_buffer_activate_video(btv, &idle);
4504         bttv_buffer_activate_vbi(btv, NULL);
4505         bttv_set_dma(btv, 0);
4506         btwrite(0, BT848_INT_MASK);
4507         spin_unlock_irqrestore(&btv->s_lock,flags);
4508
4509         /* save bt878 state */
4510         btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4511         btv->state.gpio_data   = gpio_read();
4512
4513         /* save pci state */
4514         pci_save_state(pci_dev);
4515         if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4516                 pci_disable_device(pci_dev);
4517                 btv->state.disabled = 1;
4518         }
4519         return 0;
4520 }
4521
4522 static int bttv_resume(struct pci_dev *pci_dev)
4523 {
4524         struct bttv *btv = pci_get_drvdata(pci_dev);
4525         unsigned long flags;
4526         int err;
4527
4528         dprintk("bttv%d: resume\n", btv->c.nr);
4529
4530         /* restore pci state */
4531         if (btv->state.disabled) {
4532                 err=pci_enable_device(pci_dev);
4533                 if (err) {
4534                         printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4535                                                                 btv->c.nr);
4536                         return err;
4537                 }
4538                 btv->state.disabled = 0;
4539         }
4540         err=pci_set_power_state(pci_dev, PCI_D0);
4541         if (err) {
4542                 pci_disable_device(pci_dev);
4543                 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4544                                                         btv->c.nr);
4545                 btv->state.disabled = 1;
4546                 return err;
4547         }
4548
4549         pci_restore_state(pci_dev);
4550
4551         /* restore bt878 state */
4552         bttv_reinit_bt848(btv);
4553         gpio_inout(0xffffff, btv->state.gpio_enable);
4554         gpio_write(btv->state.gpio_data);
4555
4556         /* restart dma */
4557         spin_lock_irqsave(&btv->s_lock,flags);
4558         btv->curr = btv->state.video;
4559         btv->cvbi = btv->state.vbi;
4560         btv->loop_irq = btv->state.loop_irq;
4561         bttv_buffer_activate_video(btv, &btv->curr);
4562         bttv_buffer_activate_vbi(btv, btv->cvbi);
4563         bttv_set_dma(btv, 0);
4564         spin_unlock_irqrestore(&btv->s_lock,flags);
4565         return 0;
4566 }
4567 #endif
4568
4569 static struct pci_device_id bttv_pci_tbl[] = {
4570         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
4571          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4572         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
4573          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4574         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
4575          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4576         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
4577          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4578         {0,}
4579 };
4580
4581 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4582
4583 static struct pci_driver bttv_pci_driver = {
4584         .name     = "bttv",
4585         .id_table = bttv_pci_tbl,
4586         .probe    = bttv_probe,
4587         .remove   = __devexit_p(bttv_remove),
4588 #ifdef CONFIG_PM
4589         .suspend  = bttv_suspend,
4590         .resume   = bttv_resume,
4591 #endif
4592 };
4593
4594 static int __init bttv_init_module(void)
4595 {
4596         int ret;
4597
4598         bttv_num = 0;
4599
4600         printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4601                (BTTV_VERSION_CODE >> 16) & 0xff,
4602                (BTTV_VERSION_CODE >> 8) & 0xff,
4603                BTTV_VERSION_CODE & 0xff);
4604 #ifdef SNAPSHOT
4605         printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4606                SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4607 #endif
4608         if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4609                 gbuffers = 2;
4610         if (gbufsize < 0 || gbufsize > BTTV_MAX_FBUF)
4611                 gbufsize = BTTV_MAX_FBUF;
4612         gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4613         if (bttv_verbose)
4614                 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4615                        gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4616
4617         bttv_check_chipset();
4618
4619         ret = bus_register(&bttv_sub_bus_type);
4620         if (ret < 0) {
4621                 printk(KERN_WARNING "bttv: bus_register error: %d\n", ret);
4622                 return ret;
4623         }
4624         ret = pci_register_driver(&bttv_pci_driver);
4625         if (ret < 0)
4626                 bus_unregister(&bttv_sub_bus_type);
4627
4628         return ret;
4629 }
4630
4631 static void __exit bttv_cleanup_module(void)
4632 {
4633         pci_unregister_driver(&bttv_pci_driver);
4634         bus_unregister(&bttv_sub_bus_type);
4635 }
4636
4637 module_init(bttv_init_module);
4638 module_exit(bttv_cleanup_module);
4639
4640 /*
4641  * Local variables:
4642  * c-basic-offset: 8
4643  * End:
4644  */