drivers/media/video/saa7134/saa7134-video.c

   1 /*
   2  * device driver for philips saa7134 based TV cards
   3  * video4linux video interface
   4  *
   5  * (c) 2001-03 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <linux/init.h>
  23 #include <linux/list.h>
  24 #include <linux/module.h>
  25 #include <linux/kernel.h>
  26 #include <linux/slab.h>
  27
  28 #include "saa7134-reg.h"
  29 #include "saa7134.h"
  30
  31 /* ------------------------------------------------------------------ */
  32
  33 static unsigned int video_debug   = 0;
  34 static unsigned int gbuffers      = 8;
  35 static unsigned int noninterlaced = 0;
  36 static unsigned int gbufsize      = 768*576*4;
  37 static unsigned int gbufsize_max  = 768*576*4;
  38 MODULE_PARM(video_debug,"i");
  39 MODULE_PARM_DESC(video_debug,"enable debug messages [video]");
  40 MODULE_PARM(gbuffers,"i");
  41 MODULE_PARM_DESC(gbuffers,"number of capture buffers, range 2-32");
  42 MODULE_PARM(noninterlaced,"i");
  43 MODULE_PARM_DESC(noninterlaced,"video input is noninterlaced");
  44
  45 #define dprintk(fmt, arg...)    if (video_debug) \
  46         printk(KERN_DEBUG "%s/video: " fmt, dev->name , ## arg)
  47
  48 /* ------------------------------------------------------------------ */
  49 /* data structs for video                                             */
  50
  51 static int video_out[][9] = {
  52         [CCIR656] = { 0x00, 0xb1, 0x00, 0xa1, 0x00, 0x04, 0x06, 0x00, 0x00 },
  53 };
  54
  55 static struct saa7134_format formats[] = {
  56         {
  57                 .name     = "8 bpp gray",
  58                 .fourcc   = V4L2_PIX_FMT_GREY,
  59                 .depth    = 8,
  60                 .pm       = 0x06,
  61         },{
  62                 .name     = "15 bpp RGB, le",
  63                 .fourcc   = V4L2_PIX_FMT_RGB555,
  64                 .depth    = 16,
  65                 .pm       = 0x13 | 0x80,
  66         },{
  67                 .name     = "15 bpp RGB, be",
  68                 .fourcc   = V4L2_PIX_FMT_RGB555X,
  69                 .depth    = 16,
  70                 .pm       = 0x13 | 0x80,
  71                 .bswap    = 1,
  72         },{
  73                 .name     = "16 bpp RGB, le",
  74                 .fourcc   = V4L2_PIX_FMT_RGB565,
  75                 .depth    = 16,
  76                 .pm       = 0x10 | 0x80,
  77         },{
  78                 .name     = "16 bpp RGB, be",
  79                 .fourcc   = V4L2_PIX_FMT_RGB565X,
  80                 .depth    = 16,
  81                 .pm       = 0x10 | 0x80,
  82                 .bswap    = 1,
  83         },{
  84                 .name     = "24 bpp RGB, le",
  85                 .fourcc   = V4L2_PIX_FMT_BGR24,
  86                 .depth    = 24,
  87                 .pm       = 0x11,
  88         },{
  89                 .name     = "24 bpp RGB, be",
  90                 .fourcc   = V4L2_PIX_FMT_RGB24,
  91                 .depth    = 24,
  92                 .pm       = 0x11,
  93                 .bswap    = 1,
  94         },{
  95                 .name     = "32 bpp RGB, le",
  96                 .fourcc   = V4L2_PIX_FMT_BGR32,
  97                 .depth    = 32,
  98                 .pm       = 0x12,
  99         },{
 100                 .name     = "32 bpp RGB, be",
 101                 .fourcc   = V4L2_PIX_FMT_RGB32,
 102                 .depth    = 32,
 103                 .pm       = 0x12,
 104                 .bswap    = 1,
 105                 .wswap    = 1,
 106         },{
 107                 .name     = "4:2:2 packed, YUYV",
 108                 .fourcc   = V4L2_PIX_FMT_YUYV,
 109                 .depth    = 16,
 110                 .pm       = 0x00,
 111                 .bswap    = 1,
 112                 .yuv      = 1,
 113         },{
 114                 .name     = "4:2:2 packed, UYVY",
 115                 .fourcc   = V4L2_PIX_FMT_UYVY,
 116                 .depth    = 16,
 117                 .pm       = 0x00,
 118                 .yuv      = 1,
 119         },{
 120                 .name     = "4:2:2 planar, Y-Cb-Cr",
 121                 .fourcc   = V4L2_PIX_FMT_YUV422P,
 122                 .depth    = 16,
 123                 .pm       = 0x09,
 124                 .yuv      = 1,
 125                 .planar   = 1,
 126                 .hshift   = 1,
 127                 .vshift   = 0,
 128         },{
 129                 .name     = "4:2:0 planar, Y-Cb-Cr",
 130                 .fourcc   = V4L2_PIX_FMT_YUV420,
 131                 .depth    = 12,
 132                 .pm       = 0x0a,
 133                 .yuv      = 1,
 134                 .planar   = 1,
 135                 .hshift   = 1,
 136                 .vshift   = 1,
 137         },{
 138                 .name     = "4:2:0 planar, Y-Cb-Cr",
 139                 .fourcc   = V4L2_PIX_FMT_YVU420,
 140                 .depth    = 12,
 141                 .pm       = 0x0a,
 142                 .yuv      = 1,
 143                 .planar   = 1,
 144                 .uvswap   = 1,
 145                 .hshift   = 1,
 146                 .vshift   = 1,
 147         }
 148 };
 149 #define FORMATS ARRAY_SIZE(formats)
 150
 151 static struct saa7134_tvnorm tvnorms[] = {
 152         {
 153                 .name          = "PAL",
 154                 .id            = V4L2_STD_PAL,
 155
 156                 .sync_control  = 0x18,
 157                 .luma_control  = 0x40,
 158                 .chroma_ctrl1  = 0x81,
 159                 .chroma_gain   = 0x2a,
 160                 .chroma_ctrl2  = 0x06,
 161                 .vgate_misc    = 0x1c,
 162
 163                 .h_start       = 0,
 164                 .h_stop        = 719,
 165                 .video_v_start = 24,
 166                 .video_v_stop  = 311,
 167                 .vbi_v_start   = 7,
 168                 .vbi_v_stop    = 22,
 169                 .src_timing    = 4,
 170         },{
 171                 .name          = "NTSC",
 172                 .id            = V4L2_STD_NTSC,
 173
 174                 .sync_control  = 0x59,
 175                 .luma_control  = 0x40,
 176                 .chroma_ctrl1  = 0x89,
 177                 .chroma_gain   = 0x2a,
 178                 .chroma_ctrl2  = 0x0e,
 179                 .vgate_misc    = 0x18,
 180
 181                 .h_start       = 0,
 182                 .h_stop        = 719,
 183                 .video_v_start = 22,
 184                 .video_v_stop  = 22+240,
 185                 .vbi_v_start   = 10, /* FIXME */
 186                 .vbi_v_stop    = 21, /* FIXME */
 187                 .src_timing    = 1,
 188         },{
 189                 .name          = "SECAM",
 190                 .id            = V4L2_STD_SECAM,
 191
 192                 .sync_control  = 0x18, /* old: 0x58, */
 193                 .luma_control  = 0x1b,
 194                 .chroma_ctrl1  = 0xd1,
 195                 .chroma_gain   = 0x80,
 196                 .chroma_ctrl2  = 0x00,
 197                 .vgate_misc    = 0x1c,
 198
 199                 .h_start       = 0,
 200                 .h_stop        = 719,
 201                 .video_v_start = 24,
 202                 .video_v_stop  = 311,
 203                 .vbi_v_start   = 7,
 204                 .vbi_v_stop    = 22,
 205                 .src_timing    = 4,
 206         },{
 207                 .name          = "PAL-M",
 208                 .id            = V4L2_STD_PAL_M,
 209
 210                 .sync_control  = 0x59,
 211                 .luma_control  = 0x40,
 212                 .chroma_ctrl1  = 0xb9,
 213                 .chroma_gain   = 0x2a,
 214                 .chroma_ctrl2  = 0x0e,
 215                 .vgate_misc    = 0x18,
 216
 217                 .h_start       = 0,
 218                 .h_stop        = 719,
 219                 .video_v_start = 22,
 220                 .video_v_stop  = 22+240,
 221                 .vbi_v_start   = 10, /* FIXME */
 222                 .vbi_v_stop    = 21, /* FIXME */
 223                 .src_timing    = 1,
 224         },{
 225                 .name          = "PAL-Nc",
 226                 .id            = V4L2_STD_PAL_Nc,
 227
 228                 .sync_control  = 0x18,
 229                 .luma_control  = 0x40,
 230                 .chroma_ctrl1  = 0xa1,
 231                 .chroma_gain   = 0x2a,
 232                 .chroma_ctrl2  = 0x06,
 233                 .vgate_misc    = 0x1c,
 234
 235                 .h_start       = 0,
 236                 .h_stop        = 719,
 237                 .video_v_start = 24,
 238                 .video_v_stop  = 311,
 239                 .vbi_v_start   = 7,
 240                 .vbi_v_stop    = 22,
 241                 .src_timing    = 4,
 242 #if 0
 243         },{
 244                 .name          = "AUTO",
 245                 .id            = V4L2_STD_PAL|V4L2_STD_NTSC|V4L2_STD_SECAM,
 246                 .width         = 768,
 247                 .height        = 576,
 248
 249                 .sync_control  = 0x98,
 250                 .luma_control  = 0x40,
 251                 .chroma_ctrl1  = 0x8b,
 252                 .chroma_gain   = 0x00,
 253                 .chroma_ctrl2  = 0x00,
 254                 .vgate_misc    = 0x18,
 255
 256                 .h_start       = 0,
 257                 .h_stop        = 719,
 258                 .video_v_start = 24,
 259                 .video_v_stop  = 311,
 260                 .vbi_v_start   = 7,
 261                 .vbi_v_stop    = 22,
 262                 .src_timing    = 4,
 263 #endif
 264         }
 265 };
 266 #define TVNORMS ARRAY_SIZE(tvnorms)
 267
 268 #define V4L2_CID_PRIVATE_INVERT      (V4L2_CID_PRIVATE_BASE + 0)
 269 #define V4L2_CID_PRIVATE_Y_ODD       (V4L2_CID_PRIVATE_BASE + 1)
 270 #define V4L2_CID_PRIVATE_Y_EVEN      (V4L2_CID_PRIVATE_BASE + 2)
 271 #define V4L2_CID_PRIVATE_LASTP1      (V4L2_CID_PRIVATE_BASE + 3)
 272
 273 static const struct v4l2_queryctrl no_ctrl = {
 274         .name  = "42",
 275         .flags = V4L2_CTRL_FLAG_DISABLED,
 276 };
 277 static const struct v4l2_queryctrl video_ctrls[] = {
 278         /* --- video --- */
 279         {
 280                 .id            = V4L2_CID_BRIGHTNESS,
 281                 .name          = "Brightness",
 282                 .minimum       = 0,
 283                 .maximum       = 255,
 284                 .step          = 1,
 285                 .default_value = 128,
 286                 .type          = V4L2_CTRL_TYPE_INTEGER,
 287         },{
 288                 .id            = V4L2_CID_CONTRAST,
 289                 .name          = "Contrast",
 290                 .minimum       = 0,
 291                 .maximum       = 127,
 292                 .step          = 1,
 293                 .default_value = 68,
 294                 .type          = V4L2_CTRL_TYPE_INTEGER,
 295         },{
 296                 .id            = V4L2_CID_SATURATION,
 297                 .name          = "Saturation",
 298                 .minimum       = 0,
 299                 .maximum       = 127,
 300                 .step          = 1,
 301                 .default_value = 64,
 302                 .type          = V4L2_CTRL_TYPE_INTEGER,
 303         },{
 304                 .id            = V4L2_CID_HUE,
 305                 .name          = "Hue",
 306                 .minimum       = -128,
 307                 .maximum       = 127,
 308                 .step          = 1,
 309                 .default_value = 0,
 310                 .type          = V4L2_CTRL_TYPE_INTEGER,
 311         },{
 312                 .id            = V4L2_CID_VFLIP,
 313                 .name          = "vertical flip",
 314                 .minimum       = 0,
 315                 .maximum       = 1,
 316                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
 317         },
 318         /* --- audio --- */
 319         {
 320                 .id            = V4L2_CID_AUDIO_MUTE,
 321                 .name          = "Mute",
 322                 .minimum       = 0,
 323                 .maximum       = 1,
 324                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
 325         },{
 326                 .id            = V4L2_CID_AUDIO_VOLUME,
 327                 .name          = "Volume",
 328                 .minimum       = -15,
 329                 .maximum       = 15,
 330                 .step          = 1,
 331                 .default_value = 0,
 332                 .type          = V4L2_CTRL_TYPE_INTEGER,
 333         },
 334         /* --- private --- */
 335         {
 336                 .id            = V4L2_CID_PRIVATE_INVERT,
 337                 .name          = "Invert",
 338                 .minimum       = 0,
 339                 .maximum       = 1,
 340                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
 341         },{
 342                 .id            = V4L2_CID_PRIVATE_Y_ODD,
 343                 .name          = "y offset odd field",
 344                 .minimum       = 0,
 345                 .maximum       = 128,
 346                 .default_value = 0,
 347                 .type          = V4L2_CTRL_TYPE_INTEGER,
 348         },{
 349                 .id            = V4L2_CID_PRIVATE_Y_EVEN,
 350                 .name          = "y offset even field",
 351                 .minimum       = 0,
 352                 .maximum       = 128,
 353                 .default_value = 0,
 354                 .type          = V4L2_CTRL_TYPE_INTEGER,
 355         }
 356 };
 357 static const unsigned int CTRLS = ARRAY_SIZE(video_ctrls);
 358
 359 static const struct v4l2_queryctrl* ctrl_by_id(unsigned int id)
 360 {
 361         unsigned int i;
 362
 363         for (i = 0; i < CTRLS; i++)
 364                 if (video_ctrls[i].id == id)
 365                         return video_ctrls+i;
 366         return NULL;
 367 }
 368
 369 static struct saa7134_format* format_by_fourcc(unsigned int fourcc)
 370 {
 371         unsigned int i;
 372
 373         for (i = 0; i < FORMATS; i++)
 374                 if (formats[i].fourcc == fourcc)
 375                         return formats+i;
 376         return NULL;
 377 }
 378
 379 /* ----------------------------------------------------------------------- */
 380 /* resource management                                                     */
 381
 382 static int res_get(struct saa7134_dev *dev, struct saa7134_fh *fh, unsigned int bit)
 383 {
 384         if (fh->resources & bit)
 385                 /* have it already allocated */
 386                 return 1;
 387
 388         /* is it free? */
 389         down(&dev->lock);
 390         if (dev->resources & bit) {
 391                 /* no, someone else uses it */
 392                 up(&dev->lock);
 393                 return 0;
 394         }
 395         /* it's free, grab it */
 396         fh->resources  |= bit;
 397         dev->resources |= bit;
 398         dprintk("res: get %d\n",bit);
 399         up(&dev->lock);
 400         return 1;
 401 }
 402
 403 static
 404 int res_check(struct saa7134_fh *fh, unsigned int bit)
 405 {
 406         return (fh->resources & bit);
 407 }
 408
 409 static
 410 int res_locked(struct saa7134_dev *dev, unsigned int bit)
 411 {
 412         return (dev->resources & bit);
 413 }
 414
 415 static
 416 void res_free(struct saa7134_dev *dev, struct saa7134_fh *fh, unsigned int bits)
 417 {
 418         if ((fh->resources & bits) != bits)
 419                 BUG();
 420
 421         down(&dev->lock);
 422         fh->resources  &= ~bits;
 423         dev->resources &= ~bits;
 424         dprintk("res: put %d\n",bits);
 425         up(&dev->lock);
 426 }
 427
 428 /* ------------------------------------------------------------------ */
 429
 430 static void set_tvnorm(struct saa7134_dev *dev, struct saa7134_tvnorm *norm)
 431 {
 432         struct video_channel c;
 433         int luma_control,sync_control,mux;
 434
 435         dprintk("set tv norm = %s\n",norm->name);
 436         dev->tvnorm = norm;
 437
 438         mux = card_in(dev,dev->ctl_input).vmux;
 439         luma_control = norm->luma_control;
 440         sync_control = norm->sync_control;
 441
 442         if (mux > 5)
 443                 luma_control |= 0x80; /* svideo */
 444         if (noninterlaced)
 445                 sync_control |= 0x20;
 446
 447         /* setup cropping */
 448         dev->crop_bounds.left    = norm->h_start;
 449         dev->crop_defrect.left   = norm->h_start;
 450         dev->crop_bounds.width   = norm->h_stop - norm->h_start +1;
 451         dev->crop_defrect.width  = norm->h_stop - norm->h_start +1;
 452
 453         dev->crop_bounds.top     = (norm->vbi_v_stop+1)*2;
 454         dev->crop_defrect.top    = norm->video_v_start*2;
 455         dev->crop_bounds.height  = ((norm->id & V4L2_STD_525_60) ? 524 : 624)
 456                 - dev->crop_bounds.top;
 457         dev->crop_defrect.height = (norm->video_v_stop - norm->video_v_start +1)*2;
 458
 459         dev->crop_current = dev->crop_defrect;
 460
 461         /* setup video decoder */
 462         saa_writeb(SAA7134_INCR_DELAY,            0x08);
 463         saa_writeb(SAA7134_ANALOG_IN_CTRL1,       0xc0 | mux);
 464         saa_writeb(SAA7134_ANALOG_IN_CTRL2,       0x00);
 465
 466         saa_writeb(SAA7134_ANALOG_IN_CTRL3,       0x90);
 467         saa_writeb(SAA7134_ANALOG_IN_CTRL4,       0x90);
 468         saa_writeb(SAA7134_HSYNC_START,           0xeb);
 469         saa_writeb(SAA7134_HSYNC_STOP,            0xe0);
 470         saa_writeb(SAA7134_SOURCE_TIMING1,        norm->src_timing);
 471
 472         saa_writeb(SAA7134_SYNC_CTRL,             sync_control);
 473         saa_writeb(SAA7134_LUMA_CTRL,             luma_control);
 474         saa_writeb(SAA7134_DEC_LUMA_BRIGHT,       dev->ctl_bright);
 475         saa_writeb(SAA7134_DEC_LUMA_CONTRAST,     dev->ctl_contrast);
 476
 477         saa_writeb(SAA7134_DEC_CHROMA_SATURATION, dev->ctl_saturation);
 478         saa_writeb(SAA7134_DEC_CHROMA_HUE,        dev->ctl_hue);
 479         saa_writeb(SAA7134_CHROMA_CTRL1,          norm->chroma_ctrl1);
 480         saa_writeb(SAA7134_CHROMA_GAIN,           norm->chroma_gain);
 481
 482         saa_writeb(SAA7134_CHROMA_CTRL2,          norm->chroma_ctrl2);
 483         saa_writeb(SAA7134_MODE_DELAY_CTRL,       0x00);
 484
 485         saa_writeb(SAA7134_ANALOG_ADC,            0x01);
 486         saa_writeb(SAA7134_VGATE_START,           0x11);
 487         saa_writeb(SAA7134_VGATE_STOP,            0xfe);
 488         saa_writeb(SAA7134_MISC_VGATE_MSB,        norm->vgate_misc);
 489         saa_writeb(SAA7134_RAW_DATA_GAIN,         0x40);
 490         saa_writeb(SAA7134_RAW_DATA_OFFSET,       0x80);
 491
 492         /* pass down info to the i2c chips (v4l1) */
 493         memset(&c,0,sizeof(c));
 494         c.channel = dev->ctl_input;
 495         c.norm = VIDEO_MODE_PAL;
 496         if (norm->id & V4L2_STD_NTSC)
 497                 c.norm = VIDEO_MODE_NTSC;
 498         if (norm->id & V4L2_STD_SECAM)
 499                 c.norm = VIDEO_MODE_SECAM;
 500         saa7134_i2c_call_clients(dev,VIDIOCSCHAN,&c);
 501 }
 502
 503 static void video_mux(struct saa7134_dev *dev, int input)
 504 {
 505         dprintk("video input = %d [%s]\n",input,card_in(dev,input).name);
 506         dev->ctl_input = input;
 507         set_tvnorm(dev,dev->tvnorm);
 508         saa7134_tvaudio_setinput(dev,&card_in(dev,input));
 509 }
 510
 511 static void set_h_prescale(struct saa7134_dev *dev, int task, int prescale)
 512 {
 513         static const struct {
 514                 int xpsc;
 515                 int xacl;
 516                 int xc2_1;
 517                 int xdcg;
 518                 int vpfy;
 519         } vals[] = {
 520                 /* XPSC XACL XC2_1 XDCG VPFY */
 521                 {    1,   0,    0,    0,   0 },
 522                 {    2,   2,    1,    2,   2 },
 523                 {    3,   4,    1,    3,   2 },
 524                 {    4,   8,    1,    4,   2 },
 525                 {    5,   8,    1,    4,   2 },
 526                 {    6,   8,    1,    4,   3 },
 527                 {    7,   8,    1,    4,   3 },
 528                 {    8,  15,    0,    4,   3 },
 529                 {    9,  15,    0,    4,   3 },
 530                 {   10,  16,    1,    5,   3 },
 531         };
 532         static const int count = ARRAY_SIZE(vals);
 533         int i;
 534
 535         for (i = 0; i < count; i++)
 536                 if (vals[i].xpsc == prescale)
 537                         break;
 538         if (i == count)
 539                 return;
 540
 541         saa_writeb(SAA7134_H_PRESCALE(task), vals[i].xpsc);
 542         saa_writeb(SAA7134_ACC_LENGTH(task), vals[i].xacl);
 543         saa_writeb(SAA7134_LEVEL_CTRL(task),
 544                    (vals[i].xc2_1 << 3) | (vals[i].xdcg));
 545         saa_andorb(SAA7134_FIR_PREFILTER_CTRL(task), 0x0f,
 546                    (vals[i].vpfy << 2) | vals[i].vpfy);
 547 }
 548
 549 static void set_v_scale(struct saa7134_dev *dev, int task, int yscale)
 550 {
 551         int val,mirror;
 552
 553         saa_writeb(SAA7134_V_SCALE_RATIO1(task), yscale &  0xff);
 554         saa_writeb(SAA7134_V_SCALE_RATIO2(task), yscale >> 8);
 555
 556         mirror = (dev->ctl_mirror) ? 0x02 : 0x00;
 557         if (yscale < 2048) {
 558                 /* LPI */
 559                 dprintk("yscale LPI yscale=%d\n",yscale);
 560                 saa_writeb(SAA7134_V_FILTER(task), 0x00 | mirror);
 561                 saa_writeb(SAA7134_LUMA_CONTRAST(task), 0x40);
 562                 saa_writeb(SAA7134_CHROMA_SATURATION(task), 0x40);
 563         } else {
 564                 /* ACM */
 565                 val = 0x40 * 1024 / yscale;
 566                 dprintk("yscale ACM yscale=%d val=0x%x\n",yscale,val);
 567                 saa_writeb(SAA7134_V_FILTER(task), 0x01 | mirror);
 568                 saa_writeb(SAA7134_LUMA_CONTRAST(task), val);
 569                 saa_writeb(SAA7134_CHROMA_SATURATION(task), val);
 570         }
 571         saa_writeb(SAA7134_LUMA_BRIGHT(task),       0x80);
 572 }
 573
 574 static void set_size(struct saa7134_dev *dev, int task,
 575                      int width, int height, int interlace)
 576 {
 577         int prescale,xscale,yscale,y_even,y_odd;
 578         int h_start, h_stop, v_start, v_stop;
 579         int div = interlace ? 2 : 1;
 580
 581         /* setup video scaler */
 582         h_start = dev->crop_current.left;
 583         v_start = dev->crop_current.top/2;
 584         h_stop  = (dev->crop_current.left + dev->crop_current.width -1);
 585         v_stop  = (dev->crop_current.top + dev->crop_current.height -1)/2;
 586
 587         saa_writeb(SAA7134_VIDEO_H_START1(task), h_start &  0xff);
 588         saa_writeb(SAA7134_VIDEO_H_START2(task), h_start >> 8);
 589         saa_writeb(SAA7134_VIDEO_H_STOP1(task),  h_stop  &  0xff);
 590         saa_writeb(SAA7134_VIDEO_H_STOP2(task),  h_stop  >> 8);
 591         saa_writeb(SAA7134_VIDEO_V_START1(task), v_start &  0xff);
 592         saa_writeb(SAA7134_VIDEO_V_START2(task), v_start >> 8);
 593         saa_writeb(SAA7134_VIDEO_V_STOP1(task),  v_stop  &  0xff);
 594         saa_writeb(SAA7134_VIDEO_V_STOP2(task),  v_stop  >> 8);
 595
 596         prescale = dev->crop_defrect.width / width;
 597         if (0 == prescale)
 598                 prescale = 1;
 599         xscale = 1024 * dev->crop_defrect.width / prescale / width;
 600         yscale = 512 * div * dev->crop_defrect.height / height;
 601         dprintk("prescale=%d xscale=%d yscale=%d\n",prescale,xscale,yscale);
 602         set_h_prescale(dev,task,prescale);
 603         saa_writeb(SAA7134_H_SCALE_INC1(task),      xscale &  0xff);
 604         saa_writeb(SAA7134_H_SCALE_INC2(task),      xscale >> 8);
 605         set_v_scale(dev,task,yscale);
 606
 607         saa_writeb(SAA7134_VIDEO_PIXELS1(task),     width  & 0xff);
 608         saa_writeb(SAA7134_VIDEO_PIXELS2(task),     width  >> 8);
 609         saa_writeb(SAA7134_VIDEO_LINES1(task),      height/div & 0xff);
 610         saa_writeb(SAA7134_VIDEO_LINES2(task),      height/div >> 8);
 611
 612         /* deinterlace y offsets */
 613         y_odd  = dev->ctl_y_odd;
 614         y_even = dev->ctl_y_even;
 615         saa_writeb(SAA7134_V_PHASE_OFFSET0(task), y_odd);
 616         saa_writeb(SAA7134_V_PHASE_OFFSET1(task), y_even);
 617         saa_writeb(SAA7134_V_PHASE_OFFSET2(task), y_odd);
 618         saa_writeb(SAA7134_V_PHASE_OFFSET3(task), y_even);
 619 }
 620
 621 /* ------------------------------------------------------------------ */
 622
 623 struct cliplist {
 624         __u16 position;
 625         __u8  enable;
 626         __u8  disable;
 627 };
 628
 629 static void sort_cliplist(struct cliplist *cl, int entries)
 630 {
 631         struct cliplist swap;
 632         int i,j,n;
 633
 634         for (i = entries-2; i >= 0; i--) {
 635                 for (n = 0, j = 0; j <= i; j++) {
 636                         if (cl[j].position > cl[j+1].position) {
 637                                 swap = cl[j];
 638                                 cl[j] = cl[j+1];
 639                                 cl[j+1] = swap;
 640                                 n++;
 641                         }
 642                 }
 643                 if (0 == n)
 644                         break;
 645         }
 646 }
 647
 648 static void set_cliplist(struct saa7134_dev *dev, int reg,
 649                         struct cliplist *cl, int entries, char *name)
 650 {
 651         __u8 winbits = 0;
 652         int i;
 653
 654         for (i = 0; i < entries; i++) {
 655                 winbits |= cl[i].enable;
 656                 winbits &= ~cl[i].disable;
 657                 if (i < 15 && cl[i].position == cl[i+1].position)
 658                         continue;
 659                 saa_writeb(reg + 0, winbits);
 660                 saa_writeb(reg + 2, cl[i].position & 0xff);
 661                 saa_writeb(reg + 3, cl[i].position >> 8);
 662                 dprintk("clip: %s winbits=%02x pos=%d\n",
 663                         name,winbits,cl[i].position);
 664                 reg += 8;
 665         }
 666         for (; reg < 0x400; reg += 8) {
 667                 saa_writeb(reg+ 0, 0);
 668                 saa_writeb(reg + 1, 0);
 669                 saa_writeb(reg + 2, 0);
 670                 saa_writeb(reg + 3, 0);
 671         }
 672 }
 673
 674 static int clip_range(int val)
 675 {
 676         if (val < 0)
 677                 val = 0;
 678         return val;
 679 }
 680
 681 static int setup_clipping(struct saa7134_dev *dev, struct v4l2_clip *clips,
 682                           int nclips, int interlace)
 683 {
 684         struct cliplist col[16], row[16];
 685         int cols, rows, i;
 686         int div = interlace ? 2 : 1;
 687
 688         memset(col,0,sizeof(col)); cols = 0;
 689         memset(row,0,sizeof(row)); rows = 0;
 690         for (i = 0; i < nclips && i < 8; i++) {
 691                 col[cols].position = clip_range(clips[i].c.left);
 692                 col[cols].enable   = (1 << i);
 693                 cols++;
 694                 col[cols].position = clip_range(clips[i].c.left+clips[i].c.width);
 695                 col[cols].disable  = (1 << i);
 696                 cols++;
 697                 row[rows].position = clip_range(clips[i].c.top / div);
 698                 row[rows].enable   = (1 << i);
 699                 rows++;
 700                 row[rows].position = clip_range((clips[i].c.top + clips[i].c.height)
 701                                                 / div);
 702                 row[rows].disable  = (1 << i);
 703                 rows++;
 704         }
 705         sort_cliplist(col,cols);
 706         sort_cliplist(row,rows);
 707         set_cliplist(dev,0x380,col,cols,"cols");
 708         set_cliplist(dev,0x384,row,rows,"rows");
 709         return 0;
 710 }
 711
 712 static int verify_preview(struct saa7134_dev *dev, struct v4l2_window *win)
 713 {
 714         enum v4l2_field field;
 715         int maxw, maxh;
 716
 717         if (NULL == dev->ovbuf.base)
 718                 return -EINVAL;
 719         if (NULL == dev->ovfmt)
 720                 return -EINVAL;
 721         if (win->w.width < 48 || win->w.height <  32)
 722                 return -EINVAL;
 723         if (win->clipcount > 2048)
 724                 return -EINVAL;
 725
 726         field = win->field;
 727         maxw  = dev->crop_current.width;
 728         maxh  = dev->crop_current.height;
 729
 730         if (V4L2_FIELD_ANY == field) {
 731                 field = (win->w.height > maxh/2)
 732                         ? V4L2_FIELD_INTERLACED
 733                         : V4L2_FIELD_TOP;
 734         }
 735         switch (field) {
 736         case V4L2_FIELD_TOP:
 737         case V4L2_FIELD_BOTTOM:
 738                 maxh = maxh / 2;
 739                 break;
 740         case V4L2_FIELD_INTERLACED:
 741                 break;
 742         default:
 743                 return -EINVAL;
 744         }
 745
 746         win->field = field;
 747         if (win->w.width > maxw)
 748                 win->w.width = maxw;
 749         if (win->w.height > maxh)
 750                 win->w.height = maxh;
 751         return 0;
 752 }
 753
 754 static int start_preview(struct saa7134_dev *dev, struct saa7134_fh *fh)
 755 {
 756         unsigned long base,control,bpl;
 757         int err;
 758
 759         err = verify_preview(dev,&fh->win);
 760         if (0 != err)
 761                 return err;
 762
 763         dev->ovfield = fh->win.field;
 764         dprintk("start_preview %dx%d+%d+%d %s field=%s\n",
 765                 fh->win.w.width,fh->win.w.height,
 766                 fh->win.w.left,fh->win.w.top,
 767                 dev->ovfmt->name,v4l2_field_names[dev->ovfield]);
 768
 769         /* setup window + clipping */
 770         set_size(dev,TASK_B,fh->win.w.width,fh->win.w.height,
 771                  V4L2_FIELD_HAS_BOTH(dev->ovfield));
 772         setup_clipping(dev,fh->clips,fh->nclips,
 773                        V4L2_FIELD_HAS_BOTH(dev->ovfield));
 774         if (dev->ovfmt->yuv)
 775                 saa_andorb(SAA7134_DATA_PATH(TASK_B), 0x3f, 0x03);
 776         else
 777                 saa_andorb(SAA7134_DATA_PATH(TASK_B), 0x3f, 0x01);
 778         saa_writeb(SAA7134_OFMT_VIDEO_B, dev->ovfmt->pm | 0x20);
 779
 780         /* dma: setup channel 1 (= Video Task B) */
 781         base  = (unsigned long)dev->ovbuf.base;
 782         base += dev->ovbuf.fmt.bytesperline * fh->win.w.top;
 783         base += dev->ovfmt->depth/8         * fh->win.w.left;
 784         bpl   = dev->ovbuf.fmt.bytesperline;
 785         control = SAA7134_RS_CONTROL_BURST_16;
 786         if (dev->ovfmt->bswap)
 787                 control |= SAA7134_RS_CONTROL_BSWAP;
 788         if (dev->ovfmt->wswap)
 789                 control |= SAA7134_RS_CONTROL_WSWAP;
 790         if (V4L2_FIELD_HAS_BOTH(dev->ovfield)) {
 791                 saa_writel(SAA7134_RS_BA1(1),base);
 792                 saa_writel(SAA7134_RS_BA2(1),base+bpl);
 793                 saa_writel(SAA7134_RS_PITCH(1),bpl*2);
 794                 saa_writel(SAA7134_RS_CONTROL(1),control);
 795         } else {
 796                 saa_writel(SAA7134_RS_BA1(1),base);
 797                 saa_writel(SAA7134_RS_BA2(1),base);
 798                 saa_writel(SAA7134_RS_PITCH(1),bpl);
 799                 saa_writel(SAA7134_RS_CONTROL(1),control);
 800         }
 801
 802         /* start dma */
 803         dev->ovenable = 1;
 804         saa7134_set_dmabits(dev);
 805
 806         return 0;
 807 }
 808
 809 static int stop_preview(struct saa7134_dev *dev, struct saa7134_fh *fh)
 810 {
 811         dev->ovenable = 0;
 812         saa7134_set_dmabits(dev);
 813         return 0;
 814 }
 815
 816 /* ------------------------------------------------------------------ */
 817
 818 static int buffer_activate(struct saa7134_dev *dev,
 819                            struct saa7134_buf *buf,
 820                            struct saa7134_buf *next)
 821 {
 822         unsigned long base,control,bpl;
 823         unsigned long bpl_uv,lines_uv,base2,base3,tmp; /* planar */
 824
 825         dprintk("buffer_activate buf=%p\n",buf);
 826         buf->vb.state = STATE_ACTIVE;
 827         buf->top_seen = 0;
 828
 829         set_size(dev,TASK_A,buf->vb.width,buf->vb.height,
 830                  V4L2_FIELD_HAS_BOTH(buf->vb.field));
 831         if (buf->fmt->yuv)
 832                 saa_andorb(SAA7134_DATA_PATH(TASK_A), 0x3f, 0x03);
 833         else
 834                 saa_andorb(SAA7134_DATA_PATH(TASK_A), 0x3f, 0x01);
 835         saa_writeb(SAA7134_OFMT_VIDEO_A, buf->fmt->pm);
 836
 837         /* DMA: setup channel 0 (= Video Task A0) */
 838         base  = saa7134_buffer_base(buf);
 839         if (buf->fmt->planar)
 840                 bpl = buf->vb.width;
 841         else
 842                 bpl = (buf->vb.width * buf->fmt->depth) / 8;
 843         control = SAA7134_RS_CONTROL_BURST_16 |
 844                 SAA7134_RS_CONTROL_ME |
 845                 (buf->pt->dma >> 12);
 846         if (buf->fmt->bswap)
 847                 control |= SAA7134_RS_CONTROL_BSWAP;
 848         if (buf->fmt->wswap)
 849                 control |= SAA7134_RS_CONTROL_WSWAP;
 850         if (V4L2_FIELD_HAS_BOTH(buf->vb.field)) {
 851                 /* interlaced */
 852                 saa_writel(SAA7134_RS_BA1(0),base);
 853                 saa_writel(SAA7134_RS_BA2(0),base+bpl);
 854                 saa_writel(SAA7134_RS_PITCH(0),bpl*2);
 855         } else {
 856                 /* non-interlaced */
 857                 saa_writel(SAA7134_RS_BA1(0),base);
 858                 saa_writel(SAA7134_RS_BA2(0),base);
 859                 saa_writel(SAA7134_RS_PITCH(0),bpl);
 860         }
 861         saa_writel(SAA7134_RS_CONTROL(0),control);
 862
 863         if (buf->fmt->planar) {
 864                 /* DMA: setup channel 4+5 (= planar task A) */
 865                 bpl_uv   = bpl >> buf->fmt->hshift;
 866                 lines_uv = buf->vb.height >> buf->fmt->vshift;
 867                 base2    = base + bpl * buf->vb.height;
 868                 base3    = base2 + bpl_uv * lines_uv;
 869                 if (buf->fmt->uvswap)
 870                         tmp = base2, base2 = base3, base3 = tmp;
 871                 dprintk("uv: bpl=%ld lines=%ld base2/3=%ld/%ld\n",
 872                         bpl_uv,lines_uv,base2,base3);
 873                 if (V4L2_FIELD_HAS_BOTH(buf->vb.field)) {
 874                         /* interlaced */
 875                         saa_writel(SAA7134_RS_BA1(4),base2);
 876                         saa_writel(SAA7134_RS_BA2(4),base2+bpl_uv);
 877                         saa_writel(SAA7134_RS_PITCH(4),bpl_uv*2);
 878                         saa_writel(SAA7134_RS_BA1(5),base3);
 879                         saa_writel(SAA7134_RS_BA2(5),base3+bpl_uv);
 880                         saa_writel(SAA7134_RS_PITCH(5),bpl_uv*2);
 881                 } else {
 882                         /* non-interlaced */
 883                         saa_writel(SAA7134_RS_BA1(4),base2);
 884                         saa_writel(SAA7134_RS_BA2(4),base2);
 885                         saa_writel(SAA7134_RS_PITCH(4),bpl_uv);
 886                         saa_writel(SAA7134_RS_BA1(5),base3);
 887                         saa_writel(SAA7134_RS_BA2(5),base3);
 888                         saa_writel(SAA7134_RS_PITCH(5),bpl_uv);
 889                 }
 890                 saa_writel(SAA7134_RS_CONTROL(4),control);
 891                 saa_writel(SAA7134_RS_CONTROL(5),control);
 892         }
 893
 894         /* start DMA */
 895         saa7134_set_dmabits(dev);
 896         mod_timer(&dev->video_q.timeout, jiffies+BUFFER_TIMEOUT);
 897         return 0;
 898 }
 899
 900 static int buffer_prepare(struct file *file, struct videobuf_buffer *vb,
 901                           enum v4l2_field field)
 902 {
 903         struct saa7134_fh *fh = file->private_data;
 904         struct saa7134_dev *dev = fh->dev;
 905         struct saa7134_buf *buf = (struct saa7134_buf *)vb;
 906         unsigned int size;
 907         int err;
 908
 909         /* sanity checks */
 910         if (NULL == fh->fmt)
 911                 return -EINVAL;
 912         if (fh->width  < 48 ||
 913             fh->height < 32 ||
 914             fh->width  > dev->crop_current.width ||
 915             fh->height > dev->crop_current.height)
 916                 return -EINVAL;
 917         size = (fh->width * fh->height * fh->fmt->depth) >> 3;
 918         if (0 != buf->vb.baddr  &&  buf->vb.bsize < size)
 919                 return -EINVAL;
 920
 921         dprintk("buffer_prepare [%d,size=%dx%d,bytes=%d,fields=%s,%s]\n",
 922                 vb->i,fh->width,fh->height,size,v4l2_field_names[field],
 923                 fh->fmt->name);
 924         if (buf->vb.width  != fh->width  ||
 925             buf->vb.height != fh->height ||
 926             buf->vb.size   != size       ||
 927             buf->vb.field  != field      ||
 928             buf->fmt       != fh->fmt) {
 929                 saa7134_dma_free(dev,buf);
 930         }
 931
 932         if (STATE_NEEDS_INIT == buf->vb.state) {
 933                 buf->vb.width  = fh->width;
 934                 buf->vb.height = fh->height;
 935                 buf->vb.size   = size;
 936                 buf->vb.field  = field;
 937                 buf->fmt       = fh->fmt;
 938                 buf->pt        = &fh->pt_cap;
 939
 940                 err = videobuf_iolock(dev->pci,&buf->vb,&dev->ovbuf);
 941                 if (err)
 942                         goto oops;
 943                 err = saa7134_pgtable_build(dev->pci,buf->pt,
 944                                             buf->vb.dma.sglist,
 945                                             buf->vb.dma.sglen,
 946                                             saa7134_buffer_startpage(buf));
 947                 if (err)
 948                         goto oops;
 949         }
 950         buf->vb.state = STATE_PREPARED;
 951         buf->activate = buffer_activate;
 952         return 0;
 953
 954  oops:
 955         saa7134_dma_free(dev,buf);
 956         return err;
 957 }
 958
 959 static int
 960 buffer_setup(struct file *file, unsigned int *count, unsigned int *size)
 961 {
 962         struct saa7134_fh *fh = file->private_data;
 963
 964         *size = fh->fmt->depth * fh->width * fh->height >> 3;
 965         if (0 == *count)
 966                 *count = gbuffers;
 967         *count = saa7134_buffer_count(*size,*count);
 968         return 0;
 969 }
 970
 971 static void buffer_queue(struct file *file, struct videobuf_buffer *vb)
 972 {
 973         struct saa7134_fh *fh = file->private_data;
 974         struct saa7134_buf *buf = (struct saa7134_buf *)vb;
 975
 976         saa7134_buffer_queue(fh->dev,&fh->dev->video_q,buf);
 977 }
 978
 979 static void buffer_release(struct file *file, struct videobuf_buffer *vb)
 980 {
 981         struct saa7134_fh *fh = file->private_data;
 982         struct saa7134_buf *buf = (struct saa7134_buf *)vb;
 983
 984         saa7134_dma_free(fh->dev,buf);
 985 }
 986
 987 static struct videobuf_queue_ops video_qops = {
 988         .buf_setup    = buffer_setup,
 989         .buf_prepare  = buffer_prepare,
 990         .buf_queue    = buffer_queue,
 991         .buf_release  = buffer_release,
 992 };
 993
 994 /* ------------------------------------------------------------------ */
 995
 996 static int get_control(struct saa7134_dev *dev, struct v4l2_control *c)
 997 {
 998         const struct v4l2_queryctrl* ctrl;
 999
1000         ctrl = ctrl_by_id(c->id);
1001         if (NULL == ctrl)
1002                 return -EINVAL;
1003         switch (c->id) {
1004         case V4L2_CID_BRIGHTNESS:
1005                 c->value = dev->ctl_bright;
1006                 break;
1007         case V4L2_CID_HUE:
1008                 c->value = dev->ctl_hue;
1009                 break;
1010         case V4L2_CID_CONTRAST:
1011                 c->value = dev->ctl_contrast;
1012                 break;
1013         case V4L2_CID_SATURATION:
1014                 c->value = dev->ctl_saturation;
1015                 break;
1016         case V4L2_CID_AUDIO_MUTE:
1017                 c->value = dev->ctl_mute;
1018                 break;
1019         case V4L2_CID_AUDIO_VOLUME:
1020                 c->value = dev->ctl_volume;
1021                 break;
1022         case V4L2_CID_PRIVATE_INVERT:
1023                 c->value = dev->ctl_invert;
1024                 break;
1025         case V4L2_CID_VFLIP:
1026                 c->value = dev->ctl_mirror;
1027                 break;
1028         case V4L2_CID_PRIVATE_Y_EVEN:
1029                 c->value = dev->ctl_y_even;
1030                 break;
1031         case V4L2_CID_PRIVATE_Y_ODD:
1032                 c->value = dev->ctl_y_odd;
1033                 break;
1034         default:
1035                 return -EINVAL;
1036         }
1037         return 0;
1038 }
1039
1040 static int set_control(struct saa7134_dev *dev, struct saa7134_fh *fh,
1041                        struct v4l2_control *c)
1042 {
1043         const struct v4l2_queryctrl* ctrl;
1044         unsigned long flags;
1045         int restart_overlay = 0;
1046
1047         ctrl = ctrl_by_id(c->id);
1048         if (NULL == ctrl)
1049                 return -EINVAL;
1050         dprintk("set_control name=%s val=%d\n",ctrl->name,c->value);
1051         switch (ctrl->type) {
1052         case V4L2_CTRL_TYPE_BOOLEAN:
1053         case V4L2_CTRL_TYPE_MENU:
1054         case V4L2_CTRL_TYPE_INTEGER:
1055                 if (c->value < ctrl->minimum)
1056                         c->value = ctrl->minimum;
1057                 if (c->value > ctrl->maximum)
1058                         c->value = ctrl->maximum;
1059                 break;
1060         default:
1061                 /* nothing */;
1062         };
1063         switch (c->id) {
1064         case V4L2_CID_BRIGHTNESS:
1065                 dev->ctl_bright = c->value;
1066                 saa_writeb(SAA7134_DEC_LUMA_BRIGHT, dev->ctl_bright);
1067                 break;
1068         case V4L2_CID_HUE:
1069                 dev->ctl_hue = c->value;
1070                 saa_writeb(SAA7134_DEC_CHROMA_HUE, dev->ctl_hue);
1071                 break;
1072         case V4L2_CID_CONTRAST:
1073                 dev->ctl_contrast = c->value;
1074                 saa_writeb(SAA7134_DEC_LUMA_CONTRAST,
1075                            dev->ctl_invert ? -dev->ctl_contrast : dev->ctl_contrast);
1076                 break;
1077         case V4L2_CID_SATURATION:
1078                 dev->ctl_saturation = c->value;
1079                 saa_writeb(SAA7134_DEC_CHROMA_SATURATION,
1080                            dev->ctl_invert ? -dev->ctl_saturation : dev->ctl_saturation);
1081                 break;
1082         case V4L2_CID_AUDIO_MUTE:
1083                 dev->ctl_mute = c->value;
1084                 saa7134_tvaudio_setmute(dev);
1085                 break;
1086         case V4L2_CID_AUDIO_VOLUME:
1087                 dev->ctl_volume = c->value;
1088                 saa7134_tvaudio_setvolume(dev,dev->ctl_volume);
1089                 break;
1090         case V4L2_CID_PRIVATE_INVERT:
1091                 dev->ctl_invert = c->value;
1092                 saa_writeb(SAA7134_DEC_LUMA_CONTRAST,
1093                            dev->ctl_invert ? -dev->ctl_contrast : dev->ctl_contrast);
1094                 saa_writeb(SAA7134_DEC_CHROMA_SATURATION,
1095                            dev->ctl_invert ? -dev->ctl_saturation : dev->ctl_saturation);
1096                 break;
1097         case V4L2_CID_VFLIP:
1098                 dev->ctl_mirror = c->value;
1099                 restart_overlay = 1;
1100                 break;
1101         case V4L2_CID_PRIVATE_Y_EVEN:
1102                 dev->ctl_y_even = c->value;
1103                 restart_overlay = 1;
1104                 break;
1105         case V4L2_CID_PRIVATE_Y_ODD:
1106                 dev->ctl_y_odd = c->value;
1107                 restart_overlay = 1;
1108                 break;
1109         default:
1110                 return -EINVAL;
1111         }
1112         if (restart_overlay && fh && res_check(fh, RESOURCE_OVERLAY)) {
1113                 spin_lock_irqsave(&dev->slock,flags);
1114                 stop_preview(dev,fh);
1115                 start_preview(dev,fh);
1116                 spin_unlock_irqrestore(&dev->slock,flags);
1117         }
1118         return 0;
1119 }
1120
1121 /* ------------------------------------------------------------------ */
1122
1123 static struct videobuf_queue* saa7134_queue(struct saa7134_fh *fh)
1124 {
1125         struct videobuf_queue* q = NULL;
1126
1127         switch (fh->type) {
1128         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1129                 q = &fh->cap;
1130                 break;
1131         case V4L2_BUF_TYPE_VBI_CAPTURE:
1132                 q = &fh->vbi;
1133                 break;
1134         default:
1135                 BUG();
1136         }
1137         return q;
1138 }
1139
1140 static int saa7134_resource(struct saa7134_fh *fh)
1141 {
1142         int res = 0;
1143
1144         switch (fh->type) {
1145         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1146                 res = RESOURCE_VIDEO;
1147                 break;
1148         case V4L2_BUF_TYPE_VBI_CAPTURE:
1149                 res = RESOURCE_VBI;
1150                 break;
1151         default:
1152                 BUG();
1153         }
1154         return res;
1155 }
1156
1157 static int video_open(struct inode *inode, struct file *file)
1158 {
1159         int minor = iminor(inode);
1160         struct saa7134_dev *h,*dev = NULL;
1161         struct saa7134_fh *fh;
1162         struct list_head *list;
1163         enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1164         int radio = 0;
1165
1166         list_for_each(list,&saa7134_devlist) {
1167                 h = list_entry(list, struct saa7134_dev, devlist);
1168                 if (h->video_dev && (h->video_dev->minor == minor))
1169                         dev = h;
1170                 if (h->radio_dev && (h->radio_dev->minor == minor)) {
1171                         radio = 1;
1172                         dev = h;
1173                 }
1174                 if (h->vbi_dev && (h->vbi_dev->minor == minor)) {
1175                         type = V4L2_BUF_TYPE_VBI_CAPTURE;
1176                         dev = h;
1177                 }
1178         }
1179         if (NULL == dev)
1180                 return -ENODEV;
1181
1182         dprintk("open minor=%d radio=%d type=%s\n",minor,radio,
1183                 v4l2_type_names[type]);
1184
1185         /* allocate + initialize per filehandle data */
1186         fh = kmalloc(sizeof(*fh),GFP_KERNEL);
1187         if (NULL == fh)
1188                 return -ENOMEM;
1189         memset(fh,0,sizeof(*fh));
1190         file->private_data = fh;
1191         fh->dev      = dev;
1192         fh->radio    = radio;
1193         fh->type     = type;
1194         fh->fmt      = format_by_fourcc(V4L2_PIX_FMT_BGR24);
1195         fh->width    = 768;
1196         fh->height   = 576;
1197 #ifdef VIDIOC_G_PRIORITY
1198         v4l2_prio_open(&dev->prio,&fh->prio);
1199 #endif
1200
1201         videobuf_queue_init(&fh->cap, &video_qops,
1202                             dev->pci, &dev->slock,
1203                             V4L2_BUF_TYPE_VIDEO_CAPTURE,
1204                             V4L2_FIELD_INTERLACED,
1205                             sizeof(struct saa7134_buf));
1206         init_MUTEX(&fh->cap.lock);
1207         saa7134_pgtable_alloc(dev->pci,&fh->pt_cap);
1208
1209         videobuf_queue_init(&fh->vbi, &saa7134_vbi_qops,
1210                             dev->pci, &dev->slock,
1211                             V4L2_BUF_TYPE_VBI_CAPTURE,
1212                             V4L2_FIELD_SEQ_TB,
1213                             sizeof(struct saa7134_buf));
1214         init_MUTEX(&fh->vbi.lock);
1215         saa7134_pgtable_alloc(dev->pci,&fh->pt_vbi);
1216
1217         if (fh->radio) {
1218                 /* switch to radio mode */
1219                 saa7134_tvaudio_setinput(dev,&card(dev).radio);
1220                 saa7134_i2c_call_clients(dev,AUDC_SET_RADIO,NULL);
1221         } else {
1222                 /* switch to video/vbi mode */
1223                 video_mux(dev,dev->ctl_input);
1224         }
1225         return 0;
1226 }
1227
1228 static ssize_t
1229 video_read(struct file *file, char *data, size_t count, loff_t *ppos)
1230 {
1231         struct saa7134_fh *fh = file->private_data;
1232
1233         switch (fh->type) {
1234         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1235                 if (res_locked(fh->dev,RESOURCE_VIDEO))
1236                         return -EBUSY;
1237                 return videobuf_read_one(file, saa7134_queue(fh),
1238                                          data, count, ppos);
1239         case V4L2_BUF_TYPE_VBI_CAPTURE:
1240                 if (!res_get(fh->dev,fh,RESOURCE_VBI))
1241                         return -EBUSY;
1242                 return videobuf_read_stream(file, saa7134_queue(fh),
1243                                             data, count, ppos, 1);
1244                 break;
1245         default:
1246                 BUG();
1247                 return 0;
1248         }
1249 }
1250
1251 static unsigned int
1252 video_poll(struct file *file, struct poll_table_struct *wait)
1253 {
1254         struct saa7134_fh *fh = file->private_data;
1255         struct videobuf_buffer *buf = NULL;
1256
1257         if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type)
1258                 return videobuf_poll_stream(file, &fh->vbi, wait);
1259
1260         if (res_check(fh,RESOURCE_VIDEO)) {
1261                 if (!list_empty(&fh->cap.stream))
1262                         buf = list_entry(fh->cap.stream.next, struct videobuf_buffer, stream);
1263         } else {
1264                 down(&fh->cap.lock);
1265                 if (UNSET == fh->cap.read_off) {
1266                         /* need to capture a new frame */
1267                         if (res_locked(fh->dev,RESOURCE_VIDEO)) {
1268                                 up(&fh->cap.lock);
1269                                 return POLLERR;
1270                         }
1271                         if (0 != fh->cap.ops->buf_prepare(file,fh->cap.read_buf,fh->cap.field)) {
1272                                 up(&fh->cap.lock);
1273                                 return POLLERR;
1274                         }
1275                         fh->cap.ops->buf_queue(file,fh->cap.read_buf);
1276                         fh->cap.read_off = 0;
1277                 }
1278                 up(&fh->cap.lock);
1279                 buf = fh->cap.read_buf;
1280         }
1281
1282         if (!buf)
1283                 return POLLERR;
1284
1285         poll_wait(file, &buf->done, wait);
1286         if (buf->state == STATE_DONE ||
1287             buf->state == STATE_ERROR)
1288                 return POLLIN|POLLRDNORM;
1289         return 0;
1290 }
1291
1292 static int video_release(struct inode *inode, struct file *file)
1293 {
1294         struct saa7134_fh  *fh  = file->private_data;
1295         struct saa7134_dev *dev = fh->dev;
1296         unsigned long flags;
1297
1298         /* turn off overlay */
1299         if (res_check(fh, RESOURCE_OVERLAY)) {
1300                 spin_lock_irqsave(&dev->slock,flags);
1301                 stop_preview(dev,fh);
1302                 spin_unlock_irqrestore(&dev->slock,flags);
1303                 res_free(dev,fh,RESOURCE_OVERLAY);
1304         }
1305
1306         /* stop video capture */
1307         if (res_check(fh, RESOURCE_VIDEO)) {
1308                 videobuf_streamoff(file,&fh->cap);
1309                 res_free(dev,fh,RESOURCE_VIDEO);
1310         }
1311         if (fh->cap.read_buf) {
1312                 buffer_release(file,fh->cap.read_buf);
1313                 kfree(fh->cap.read_buf);
1314         }
1315
1316         /* stop vbi capture */
1317         if (res_check(fh, RESOURCE_VBI)) {
1318                 if (fh->vbi.streaming)
1319                         videobuf_streamoff(file,&fh->vbi);
1320                 if (fh->vbi.reading)
1321                         videobuf_read_stop(file,&fh->vbi);
1322                 res_free(dev,fh,RESOURCE_VBI);
1323         }
1324
1325         saa7134_pgtable_free(dev->pci,&fh->pt_cap);
1326         saa7134_pgtable_free(dev->pci,&fh->pt_vbi);
1327
1328 #ifdef VIDIOC_G_PRIORITY
1329         v4l2_prio_close(&dev->prio,&fh->prio);
1330 #endif
1331         file->private_data = NULL;
1332         kfree(fh);
1333         return 0;
1334 }
1335
1336 static int
1337 video_mmap(struct file *file, struct vm_area_struct * vma)
1338 {
1339         struct saa7134_fh *fh = file->private_data;
1340
1341         return videobuf_mmap_mapper(vma,saa7134_queue(fh));
1342 }
1343
1344 /* ------------------------------------------------------------------ */
1345
1346 void saa7134_vbi_fmt(struct saa7134_dev *dev, struct v4l2_format *f)
1347 {
1348         struct saa7134_tvnorm *norm = dev->tvnorm;
1349
1350         f->fmt.vbi.sampling_rate = 6750000 * 4;
1351         f->fmt.vbi.samples_per_line = 2048 /* VBI_LINE_LENGTH */;
1352         f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1353         f->fmt.vbi.offset = 64 * 4;
1354         f->fmt.vbi.start[0] = norm->vbi_v_start;
1355         f->fmt.vbi.count[0] = norm->vbi_v_stop - norm->vbi_v_start +1;
1356         f->fmt.vbi.start[1] = norm->video_v_stop + norm->vbi_v_start +1;
1357         f->fmt.vbi.count[1] = f->fmt.vbi.count[0];
1358         f->fmt.vbi.flags = 0; /* VBI_UNSYNC VBI_INTERLACED */
1359
1360 #if 0
1361         if (V4L2_STD_PAL == norm->id) {
1362                 /* FIXME */
1363                 f->fmt.vbi.start[0] += 3;
1364                 f->fmt.vbi.start[1] += 3*2;
1365         }
1366 #endif
1367 }
1368
1369 int saa7134_g_fmt(struct saa7134_dev *dev, struct saa7134_fh *fh,
1370                   struct v4l2_format *f)
1371 {
1372         switch (f->type) {
1373         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1374                 memset(&f->fmt.pix,0,sizeof(f->fmt.pix));
1375                 f->fmt.pix.width        = fh->width;
1376                 f->fmt.pix.height       = fh->height;
1377                 f->fmt.pix.field        = fh->cap.field;
1378                 f->fmt.pix.pixelformat  = fh->fmt->fourcc;
1379                 f->fmt.pix.bytesperline =
1380                         (f->fmt.pix.width * fh->fmt->depth) >> 3;
1381                 f->fmt.pix.sizeimage =
1382                         f->fmt.pix.height * f->fmt.pix.bytesperline;
1383                 return 0;
1384         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1385                 f->fmt.win = fh->win;
1386                 return 0;
1387         case V4L2_BUF_TYPE_VBI_CAPTURE:
1388                 saa7134_vbi_fmt(dev,f);
1389                 return 0;
1390         default:
1391                 return -EINVAL;
1392         }
1393 }
1394
1395 int saa7134_try_fmt(struct saa7134_dev *dev, struct saa7134_fh *fh,
1396                     struct v4l2_format *f)
1397 {
1398         int err;
1399
1400         switch (f->type) {
1401         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1402         {
1403                 struct saa7134_format *fmt;
1404                 enum v4l2_field field;
1405                 unsigned int maxw, maxh;
1406
1407                 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1408                 if (NULL == fmt)
1409                         return -EINVAL;
1410
1411                 field = f->fmt.pix.field;
1412                 maxw  = dev->crop_current.width;
1413                 maxh  = dev->crop_current.height;
1414
1415                 if (V4L2_FIELD_ANY == field) {
1416                         field = (f->fmt.pix.height > maxh/2)
1417                                 ? V4L2_FIELD_INTERLACED
1418                                 : V4L2_FIELD_BOTTOM;
1419                 }
1420                 switch (field) {
1421                 case V4L2_FIELD_TOP:
1422                 case V4L2_FIELD_BOTTOM:
1423                         maxh = maxh / 2;
1424                         break;
1425                 case V4L2_FIELD_INTERLACED:
1426                         break;
1427                 default:
1428                         return -EINVAL;
1429                 }
1430
1431                 f->fmt.pix.field = field;
1432                 if (f->fmt.pix.width  < 48)
1433                         f->fmt.pix.width  = 48;
1434                 if (f->fmt.pix.height < 32)
1435                         f->fmt.pix.height = 32;
1436                 if (f->fmt.pix.width > maxw)
1437                         f->fmt.pix.width = maxw;
1438                 if (f->fmt.pix.height > maxh)
1439                         f->fmt.pix.height = maxh;
1440                 f->fmt.pix.bytesperline =
1441                         (f->fmt.pix.width * fmt->depth) >> 3;
1442                 f->fmt.pix.sizeimage =
1443                         f->fmt.pix.height * f->fmt.pix.bytesperline;
1444
1445                 return 0;
1446         }
1447         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1448                 err = verify_preview(dev,&f->fmt.win);
1449                 if (0 != err)
1450                         return err;
1451                 return 0;
1452         case V4L2_BUF_TYPE_VBI_CAPTURE:
1453                 saa7134_vbi_fmt(dev,f);
1454                 return 0;
1455         default:
1456                 return -EINVAL;
1457         }
1458 }
1459
1460 int saa7134_s_fmt(struct saa7134_dev *dev, struct saa7134_fh *fh,
1461                   struct v4l2_format *f)
1462 {
1463         unsigned long flags;
1464         int err;
1465
1466         switch (f->type) {
1467         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1468                 err = saa7134_try_fmt(dev,fh,f);
1469                 if (0 != err)
1470                         return err;
1471
1472                 fh->fmt       = format_by_fourcc(f->fmt.pix.pixelformat);
1473                 fh->width     = f->fmt.pix.width;
1474                 fh->height    = f->fmt.pix.height;
1475                 fh->cap.field = f->fmt.pix.field;
1476                 return 0;
1477         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1478                 err = verify_preview(dev,&f->fmt.win);
1479                 if (0 != err)
1480                         return err;
1481
1482                 down(&dev->lock);
1483                 fh->win    = f->fmt.win;
1484                 fh->nclips = f->fmt.win.clipcount;
1485                 if (fh->nclips > 8)
1486                         fh->nclips = 8;
1487                 if (copy_from_user(fh->clips,f->fmt.win.clips,
1488                                    sizeof(struct v4l2_clip)*fh->nclips)) {
1489                         up(&dev->lock);
1490                         return -EFAULT;
1491                 }
1492
1493                 if (res_check(fh, RESOURCE_OVERLAY)) {
1494                         spin_lock_irqsave(&dev->slock,flags);
1495                         stop_preview(dev,fh);
1496                         start_preview(dev,fh);
1497                         spin_unlock_irqrestore(&dev->slock,flags);
1498                 }
1499                 up(&dev->lock);
1500                 return 0;
1501         case V4L2_BUF_TYPE_VBI_CAPTURE:
1502                 saa7134_vbi_fmt(dev,f);
1503                 return 0;
1504         default:
1505                 return -EINVAL;
1506         }
1507 }
1508
1509 int saa7134_common_ioctl(struct saa7134_dev *dev,
1510                          unsigned int cmd, void *arg)
1511 {
1512         int err;
1513
1514         switch (cmd) {
1515         case VIDIOC_QUERYCTRL:
1516         {
1517                 const struct v4l2_queryctrl *ctrl;
1518                 struct v4l2_queryctrl *c = arg;
1519
1520                 if ((c->id <  V4L2_CID_BASE ||
1521                      c->id >= V4L2_CID_LASTP1) &&
1522                     (c->id <  V4L2_CID_PRIVATE_BASE ||
1523                      c->id >= V4L2_CID_PRIVATE_LASTP1))
1524                         return -EINVAL;
1525                 ctrl = ctrl_by_id(c->id);
1526                 *c = (NULL != ctrl) ? *ctrl : no_ctrl;
1527                 return 0;
1528         }
1529         case VIDIOC_G_CTRL:
1530                 return get_control(dev,arg);
1531         case VIDIOC_S_CTRL:
1532         {
1533                 down(&dev->lock);
1534                 err = set_control(dev,NULL,arg);
1535                 up(&dev->lock);
1536                 return err;
1537         }
1538         /* --- input switching --------------------------------------- */
1539         case VIDIOC_ENUMINPUT:
1540         {
1541                 struct v4l2_input *i = arg;
1542                 unsigned int n;
1543
1544                 n = i->index;
1545                 if (n >= SAA7134_INPUT_MAX)
1546                         return -EINVAL;
1547                 if (NULL == card_in(dev,i->index).name)
1548                         return -EINVAL;
1549                 memset(i,0,sizeof(*i));
1550                 i->index = n;
1551                 i->type  = V4L2_INPUT_TYPE_CAMERA;
1552                 strcpy(i->name,card_in(dev,n).name);
1553                 if (card_in(dev,n).tv)
1554                         i->type = V4L2_INPUT_TYPE_TUNER;
1555                 i->audioset = 1;
1556                 if (n == dev->ctl_input) {
1557                         int v1 = saa_readb(SAA7134_STATUS_VIDEO1);
1558                         int v2 = saa_readb(SAA7134_STATUS_VIDEO2);
1559
1560                         if (0 != (v1 & 0x40))
1561                                 i->status |= V4L2_IN_ST_NO_H_LOCK;
1562                         if (0 != (v2 & 0x40))
1563                                 i->status |= V4L2_IN_ST_NO_SYNC;
1564                         if (0 != (v2 & 0x0e))
1565                                 i->status |= V4L2_IN_ST_MACROVISION;
1566                 }
1567                 for (n = 0; n < TVNORMS; n++)
1568                         i->std |= tvnorms[n].id;
1569                 return 0;
1570         }
1571         case VIDIOC_G_INPUT:
1572         {
1573                 int *i = arg;
1574                 *i = dev->ctl_input;
1575                 return 0;
1576         }
1577         case VIDIOC_S_INPUT:
1578         {
1579                 int *i = arg;
1580
1581                 if (*i < 0  ||  *i >= SAA7134_INPUT_MAX)
1582                         return -EINVAL;
1583                 if (NULL == card_in(dev,*i).name)
1584                         return -EINVAL;
1585                 down(&dev->lock);
1586                 video_mux(dev,*i);
1587                 up(&dev->lock);
1588                 return 0;
1589         }
1590
1591         }
1592         return 0;
1593 }
1594
1595 /*
1596  * This function is _not_ called directly, but from
1597  * video_generic_ioctl (and maybe others).  userspace
1598  * copying is done already, arg is a kernel pointer.
1599  */
1600 static int video_do_ioctl(struct inode *inode, struct file *file,
1601                           unsigned int cmd, void *arg)
1602 {
1603         struct saa7134_fh *fh = file->private_data;
1604         struct saa7134_dev *dev = fh->dev;
1605         unsigned long flags;
1606         int err;
1607
1608         if (video_debug > 1)
1609                 saa7134_print_ioctl(dev->name,cmd);
1610
1611 #ifdef VIDIOC_G_PRIORITY
1612         switch (cmd) {
1613         case VIDIOC_S_CTRL:
1614         case VIDIOC_S_STD:
1615         case VIDIOC_S_INPUT:
1616         case VIDIOC_S_TUNER:
1617         case VIDIOC_S_FREQUENCY:
1618                 err = v4l2_prio_check(&dev->prio,&fh->prio);
1619                 if (0 != err)
1620                         return err;
1621         }
1622 #endif
1623
1624         switch (cmd) {
1625         case VIDIOC_QUERYCAP:
1626         {
1627                 struct v4l2_capability *cap = arg;
1628
1629                 memset(cap,0,sizeof(*cap));
1630                 strcpy(cap->driver, "saa7134");
1631                 strlcpy(cap->card, saa7134_boards[dev->board].name,
1632                         sizeof(cap->card));
1633                 sprintf(cap->bus_info,"PCI:%s",pci_name(dev->pci));
1634                 cap->version = SAA7134_VERSION_CODE;
1635                 cap->capabilities =
1636                         V4L2_CAP_VIDEO_CAPTURE |
1637                         V4L2_CAP_VIDEO_OVERLAY |
1638                         V4L2_CAP_VBI_CAPTURE |
1639                         V4L2_CAP_TUNER |
1640                         V4L2_CAP_READWRITE |
1641                         V4L2_CAP_STREAMING;
1642                 return 0;
1643         }
1644
1645         /* --- tv standards ------------------------------------------ */
1646         case VIDIOC_ENUMSTD:
1647         {
1648                 struct v4l2_standard *e = arg;
1649                 unsigned int i;
1650
1651                 i = e->index;
1652                 if (i >= TVNORMS)
1653                         return -EINVAL;
1654                 err = v4l2_video_std_construct(e, tvnorms[e->index].id,
1655                                                tvnorms[e->index].name);
1656                 e->index = i;
1657                 if (err < 0)
1658                         return err;
1659                 return 0;
1660         }
1661         case VIDIOC_G_STD:
1662         {
1663                 v4l2_std_id *id = arg;
1664
1665                 *id = dev->tvnorm->id;
1666                 return 0;
1667         }
1668         case VIDIOC_S_STD:
1669         {
1670                 v4l2_std_id *id = arg;
1671                 unsigned int i;
1672
1673                 for(i = 0; i < TVNORMS; i++)
1674                         if (*id & tvnorms[i].id)
1675                                 break;
1676                 if (i == TVNORMS)
1677                         return -EINVAL;
1678
1679                 down(&dev->lock);
1680                 if (res_check(fh, RESOURCE_OVERLAY)) {
1681                         spin_lock_irqsave(&dev->slock,flags);
1682                         stop_preview(dev,fh);
1683                         set_tvnorm(dev,&tvnorms[i]);
1684                         start_preview(dev,fh);
1685                         spin_unlock_irqrestore(&dev->slock,flags);
1686                 } else
1687                         set_tvnorm(dev,&tvnorms[i]);
1688                 up(&dev->lock);
1689                 return 0;
1690         }
1691
1692         case VIDIOC_CROPCAP:
1693         {
1694                 struct v4l2_cropcap *cap = arg;
1695
1696                 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1697                     cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
1698                         return -EINVAL;
1699                 cap->bounds  = dev->crop_bounds;
1700                 cap->defrect = dev->crop_defrect;
1701                 cap->pixelaspect.numerator   = 1;
1702                 cap->pixelaspect.denominator = 1;
1703                 if (dev->tvnorm->id & V4L2_STD_525_60) {
1704                         cap->pixelaspect.numerator   = 11;
1705                         cap->pixelaspect.denominator = 10;
1706                 }
1707                 if (dev->tvnorm->id & V4L2_STD_625_50) {
1708                         cap->pixelaspect.numerator   = 54;
1709                         cap->pixelaspect.denominator = 59;
1710                 }
1711                 return 0;
1712         }
1713
1714         case VIDIOC_G_CROP:
1715         {
1716                 struct v4l2_crop * crop = arg;
1717
1718                 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1719                     crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
1720                         return -EINVAL;
1721                 crop->c = dev->crop_current;
1722                 return 0;
1723         }
1724         case VIDIOC_S_CROP:
1725         {
1726                 struct v4l2_crop *crop = arg;
1727                 struct v4l2_rect *b = &dev->crop_bounds;
1728
1729                 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1730                     crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
1731                         return -EINVAL;
1732                 if (crop->c.height < 0)
1733                         return -EINVAL;
1734                 if (crop->c.width < 0)
1735                         return -EINVAL;
1736
1737                 if (res_locked(fh->dev,RESOURCE_OVERLAY))
1738                         return -EBUSY;
1739                 if (res_locked(fh->dev,RESOURCE_VIDEO))
1740                         return -EBUSY;
1741
1742                 if (crop->c.top < b->top)
1743                         crop->c.top = b->top;
1744                 if (crop->c.top > b->top + b->height)
1745                         crop->c.top = b->top + b->height;
1746                 if (crop->c.height > b->top - crop->c.top + b->height)
1747                         crop->c.height = b->top - crop->c.top + b->height;
1748
1749                 if (crop->c.left < b->left)
1750                         crop->c.top = b->left;
1751                 if (crop->c.left > b->left + b->width)
1752                         crop->c.top = b->left + b->width;
1753                 if (crop->c.width > b->left - crop->c.left + b->width)
1754                         crop->c.width = b->left - crop->c.left + b->width;
1755
1756                 dev->crop_current = crop->c;
1757                 return 0;
1758         }
1759
1760         /* --- tuner ioctls ------------------------------------------ */
1761         case VIDIOC_G_TUNER:
1762         {
1763                 struct v4l2_tuner *t = arg;
1764                 int n;
1765
1766                 if (0 != t->index)
1767                         return -EINVAL;
1768                 memset(t,0,sizeof(*t));
1769                 for (n = 0; n < SAA7134_INPUT_MAX; n++)
1770                         if (card_in(dev,n).tv)
1771                                 break;
1772                 if (NULL != card_in(dev,n).name) {
1773                         strcpy(t->name, "Television");
1774                         t->capability = V4L2_TUNER_CAP_NORM |
1775                                 V4L2_TUNER_CAP_STEREO |
1776                                 V4L2_TUNER_CAP_LANG1 |
1777                                 V4L2_TUNER_CAP_LANG2;
1778                         t->rangehigh = 0xffffffffUL;
1779                         t->rxsubchans = saa7134_tvaudio_getstereo(dev);
1780                         t->audmode = saa7134_tvaudio_rx2mode(t->rxsubchans);
1781                 }
1782                 if (0 != (saa_readb(SAA7134_STATUS_VIDEO1) & 0x03))
1783                         t->signal = 0xffff;
1784                 return 0;
1785         }
1786         case VIDIOC_S_TUNER:
1787         {
1788                 struct v4l2_tuner *t = arg;
1789                 int rx,mode;
1790
1791                 mode = dev->thread.mode;
1792                 if (UNSET == mode) {
1793                         rx   = saa7134_tvaudio_getstereo(dev);
1794                         mode = saa7134_tvaudio_rx2mode(t->rxsubchans);
1795                 }
1796                 if (mode != t->audmode) {
1797                         dev->thread.mode = t->audmode;
1798                 }
1799                 return 0;
1800         }
1801         case VIDIOC_G_FREQUENCY:
1802         {
1803                 struct v4l2_frequency *f = arg;
1804
1805                 memset(f,0,sizeof(*f));
1806                 f->type = V4L2_TUNER_ANALOG_TV;
1807                 f->frequency = dev->ctl_freq;
1808                 return 0;
1809         }
1810         case VIDIOC_S_FREQUENCY:
1811         {
1812                 struct v4l2_frequency *f = arg;
1813
1814                 if (0 != f->tuner)
1815                         return -EINVAL;
1816                 if (V4L2_TUNER_ANALOG_TV != f->type)
1817                         return -EINVAL;
1818                 down(&dev->lock);
1819                 dev->ctl_freq = f->frequency;
1820                 saa7134_i2c_call_clients(dev,VIDIOCSFREQ,&dev->ctl_freq);
1821                 saa7134_tvaudio_do_scan(dev);
1822                 up(&dev->lock);
1823                 return 0;
1824         }
1825
1826         /* --- control ioctls ---------------------------------------- */
1827         case VIDIOC_ENUMINPUT:
1828         case VIDIOC_G_INPUT:
1829         case VIDIOC_S_INPUT:
1830         case VIDIOC_QUERYCTRL:
1831         case VIDIOC_G_CTRL:
1832         case VIDIOC_S_CTRL:
1833                 return saa7134_common_ioctl(dev, cmd, arg);
1834
1835         case VIDIOC_G_AUDIO:
1836         {
1837                 struct v4l2_audio *a = arg;
1838
1839                 memset(a,0,sizeof(*a));
1840                 strcpy(a->name,"audio");
1841                 return 0;
1842         }
1843         case VIDIOC_S_AUDIO:
1844                 return 0;
1845         case VIDIOC_G_PARM:
1846         {
1847                 struct v4l2_captureparm *parm = arg;
1848                 memset(parm,0,sizeof(*parm));
1849                 return 0;
1850         }
1851
1852 #ifdef VIDIOC_G_PRIORITY
1853         case VIDIOC_G_PRIORITY:
1854         {
1855                 enum v4l2_priority *p = arg;
1856
1857                 *p = v4l2_prio_max(&dev->prio);
1858                 return 0;
1859         }
1860         case VIDIOC_S_PRIORITY:
1861         {
1862                 enum v4l2_priority *prio = arg;
1863
1864                 return v4l2_prio_change(&dev->prio, &fh->prio, *prio);
1865         }
1866 #endif
1867
1868         /* --- preview ioctls ---------------------------------------- */
1869         case VIDIOC_ENUM_FMT:
1870         {
1871                 struct v4l2_fmtdesc *f = arg;
1872                 enum v4l2_buf_type type;
1873                 unsigned int index;
1874
1875                 index = f->index;
1876                 type  = f->type;
1877                 switch (type) {
1878                 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1879                 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1880                         if (index >= FORMATS)
1881                                 return -EINVAL;
1882                         if (f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY &&
1883                             formats[index].planar)
1884                                 return -EINVAL;
1885                         memset(f,0,sizeof(*f));
1886                         f->index = index;
1887                         f->type  = type;
1888                         strlcpy(f->description,formats[index].name,sizeof(f->description));
1889                         f->pixelformat = formats[index].fourcc;
1890                         break;
1891                 case V4L2_BUF_TYPE_VBI_CAPTURE:
1892                         if (0 != index)
1893                                 return -EINVAL;
1894                         memset(f,0,sizeof(*f));
1895                         f->index = index;
1896                         f->type  = type;
1897                         f->pixelformat = V4L2_PIX_FMT_GREY;
1898                         strcpy(f->description,"vbi data");
1899                         break;
1900                 default:
1901                         return -EINVAL;
1902                 }
1903                 return 0;
1904         }
1905         case VIDIOC_G_FBUF:
1906         {
1907                 struct v4l2_framebuffer *fb = arg;
1908
1909                 *fb = dev->ovbuf;
1910                 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
1911                 return 0;
1912         }
1913         case VIDIOC_S_FBUF:
1914         {
1915                 struct v4l2_framebuffer *fb = arg;
1916                 struct saa7134_format *fmt;
1917
1918                 if(!capable(CAP_SYS_ADMIN) &&
1919                    !capable(CAP_SYS_RAWIO))
1920                         return -EPERM;
1921
1922                 /* check args */
1923                 fmt = format_by_fourcc(fb->fmt.pixelformat);
1924                 if (NULL == fmt)
1925                         return -EINVAL;
1926
1927                 /* ok, accept it */
1928                 dev->ovbuf = *fb;
1929                 dev->ovfmt = fmt;
1930                 if (0 == dev->ovbuf.fmt.bytesperline)
1931                         dev->ovbuf.fmt.bytesperline =
1932                                 dev->ovbuf.fmt.width*fmt->depth/8;
1933                 return 0;
1934         }
1935         case VIDIOC_OVERLAY:
1936         {
1937                 int *on = arg;
1938
1939                 if (*on) {
1940                         if (!res_get(dev,fh,RESOURCE_OVERLAY))
1941                                 return -EBUSY;
1942                         spin_lock_irqsave(&dev->slock,flags);
1943                         start_preview(dev,fh);
1944                         spin_unlock_irqrestore(&dev->slock,flags);
1945                 }
1946                 if (!*on) {
1947                         if (!res_check(fh, RESOURCE_OVERLAY))
1948                                 return -EINVAL;
1949                         spin_lock_irqsave(&dev->slock,flags);
1950                         stop_preview(dev,fh);
1951                         spin_unlock_irqrestore(&dev->slock,flags);
1952                         res_free(dev,fh,RESOURCE_OVERLAY);
1953                 }
1954                 return 0;
1955         }
1956
1957         /* --- capture ioctls ---------------------------------------- */
1958         case VIDIOC_G_FMT:
1959         {
1960                 struct v4l2_format *f = arg;
1961                 return saa7134_g_fmt(dev,fh,f);
1962         }
1963         case VIDIOC_S_FMT:
1964         {
1965                 struct v4l2_format *f = arg;
1966                 return saa7134_s_fmt(dev,fh,f);
1967         }
1968         case VIDIOC_TRY_FMT:
1969         {
1970                 struct v4l2_format *f = arg;
1971                 return saa7134_try_fmt(dev,fh,f);
1972         }
1973
1974         case VIDIOCGMBUF:
1975         {
1976                 struct video_mbuf *mbuf = arg;
1977                 struct videobuf_queue *q;
1978                 struct v4l2_requestbuffers req;
1979                 unsigned int i;
1980
1981                 q = saa7134_queue(fh);
1982                 memset(&req,0,sizeof(req));
1983                 req.type   = q->type;
1984                 req.count  = gbuffers;
1985                 req.memory = V4L2_MEMORY_MMAP;
1986                 err = videobuf_reqbufs(file,q,&req);
1987                 if (err < 0)
1988                         return err;
1989                 memset(mbuf,0,sizeof(*mbuf));
1990                 mbuf->frames = req.count;
1991                 mbuf->size   = 0;
1992                 for (i = 0; i < mbuf->frames; i++) {
1993                         mbuf->offsets[i]  = q->bufs[i]->boff;
1994                         mbuf->size       += q->bufs[i]->bsize;
1995                 }
1996                 return 0;
1997         }
1998         case VIDIOC_REQBUFS:
1999                 return videobuf_reqbufs(file,saa7134_queue(fh),arg);
2000
2001         case VIDIOC_QUERYBUF:
2002                 return videobuf_querybuf(saa7134_queue(fh),arg);
2003
2004         case VIDIOC_QBUF:
2005                 return videobuf_qbuf(file,saa7134_queue(fh),arg);
2006
2007         case VIDIOC_DQBUF:
2008                 return videobuf_dqbuf(file,saa7134_queue(fh),arg);
2009
2010         case VIDIOC_STREAMON:
2011         {
2012                 int res = saa7134_resource(fh);
2013
2014                 if (!res_get(dev,fh,res))
2015                         return -EBUSY;
2016                 return videobuf_streamon(file,saa7134_queue(fh));
2017         }
2018         case VIDIOC_STREAMOFF:
2019         {
2020                 int res = saa7134_resource(fh);
2021
2022                 err = videobuf_streamoff(file,saa7134_queue(fh));
2023                 if (err < 0)
2024                         return err;
2025                 res_free(dev,fh,res);
2026                 return 0;
2027         }
2028
2029         default:
2030                 return v4l_compat_translate_ioctl(inode,file,cmd,arg,
2031                                                   video_do_ioctl);
2032         }
2033         return 0;
2034 }
2035
2036 static int video_ioctl(struct inode *inode, struct file *file,
2037                        unsigned int cmd, unsigned long arg)
2038 {
2039         return video_usercopy(inode, file, cmd, arg, video_do_ioctl);
2040 }
2041
2042 static int radio_do_ioctl(struct inode *inode, struct file *file,
2043                           unsigned int cmd, void *arg)
2044 {
2045         struct saa7134_fh *fh = file->private_data;
2046         struct saa7134_dev *dev = fh->dev;
2047
2048         if (video_debug > 1)
2049                 saa7134_print_ioctl(dev->name,cmd);
2050         switch (cmd) {
2051         case VIDIOC_QUERYCAP:
2052         {
2053                 struct v4l2_capability *cap = arg;
2054
2055                 memset(cap,0,sizeof(*cap));
2056                 strcpy(cap->driver, "saa7134");
2057                 strlcpy(cap->card, saa7134_boards[dev->board].name,
2058                         sizeof(cap->card));
2059                 sprintf(cap->bus_info,"PCI:%s",pci_name(dev->pci));
2060                 cap->version = SAA7134_VERSION_CODE;
2061                 cap->capabilities = V4L2_CAP_TUNER;
2062                 return 0;
2063         }
2064         case VIDIOC_G_TUNER:
2065         {
2066                 struct v4l2_tuner *t = arg;
2067                 struct video_tuner vt;
2068
2069                 if (0 != t->index)
2070                         return -EINVAL;
2071
2072                 memset(t,0,sizeof(*t));
2073                 strcpy(t->name, "Radio");
2074                 t->rangelow  = (int)(65*16);
2075                 t->rangehigh = (int)(108*16);
2076
2077                 memset(&vt,0,sizeof(vt));
2078                 saa7134_i2c_call_clients(dev,VIDIOCGTUNER,&vt);
2079                 t->signal = vt.signal;
2080                 return 0;
2081         }
2082         case VIDIOC_ENUMINPUT:
2083         {
2084                 struct v4l2_input *i = arg;
2085
2086                 if (i->index != 0)
2087                         return -EINVAL;
2088                 strcpy(i->name,"Radio");
2089                 i->type = V4L2_INPUT_TYPE_TUNER;
2090                 return 0;
2091         }
2092         case VIDIOC_G_INPUT:
2093         {
2094                 int *i = arg;
2095                 *i = 0;
2096                 return 0;
2097         }
2098         case VIDIOC_G_AUDIO:
2099         {
2100                 struct v4l2_audio *a = arg;
2101
2102                 memset(a,0,sizeof(*a));
2103                 strcpy(a->name,"Radio");
2104                 return 0;
2105         }
2106         case VIDIOC_G_STD:
2107         {
2108                 v4l2_std_id *id = arg;
2109                 *id = 0;
2110                 return 0;
2111         }
2112         case VIDIOC_S_AUDIO:
2113         case VIDIOC_S_TUNER:
2114         case VIDIOC_S_INPUT:
2115         case VIDIOC_S_STD:
2116                 return 0;
2117
2118         case VIDIOC_QUERYCTRL:
2119         {
2120                 const struct v4l2_queryctrl *ctrl;
2121                 struct v4l2_queryctrl *c = arg;
2122
2123                 if (c->id <  V4L2_CID_BASE ||
2124                     c->id >= V4L2_CID_LASTP1)
2125                         return -EINVAL;
2126                 if (c->id == V4L2_CID_AUDIO_MUTE) {
2127                         ctrl = ctrl_by_id(c->id);
2128                         *c = *ctrl;
2129                 } else
2130                         *c = no_ctrl;
2131                 return 0;
2132         }
2133
2134         case VIDIOC_G_CTRL:
2135         case VIDIOC_S_CTRL:
2136         case VIDIOC_G_FREQUENCY:
2137         case VIDIOC_S_FREQUENCY:
2138                 return video_do_ioctl(inode,file,cmd,arg);
2139
2140         default:
2141                 return v4l_compat_translate_ioctl(inode,file,cmd,arg,
2142                                                   radio_do_ioctl);
2143         }
2144         return 0;
2145 }
2146
2147 static int radio_ioctl(struct inode *inode, struct file *file,
2148                        unsigned int cmd, unsigned long arg)
2149 {
2150         return video_usercopy(inode, file, cmd, arg, radio_do_ioctl);
2151 }
2152
2153 static struct file_operations video_fops =
2154 {
2155         .owner    = THIS_MODULE,
2156         .open     = video_open,
2157         .release  = video_release,
2158         .read     = video_read,
2159         .poll     = video_poll,
2160         .mmap     = video_mmap,
2161         .ioctl    = video_ioctl,
2162         .llseek   = no_llseek,
2163 };
2164
2165 static struct file_operations radio_fops =
2166 {
2167         .owner    = THIS_MODULE,
2168         .open     = video_open,
2169         .release  = video_release,
2170         .ioctl    = radio_ioctl,
2171         .llseek   = no_llseek,
2172 };
2173
2174 /* ----------------------------------------------------------- */
2175 /* exported stuff                                              */
2176
2177 struct video_device saa7134_video_template =
2178 {
2179         .name          = "saa7134-video",
2180         .type          = VID_TYPE_CAPTURE|VID_TYPE_TUNER|VID_TYPE_OVERLAY|
2181                          VID_TYPE_CLIPPING|VID_TYPE_SCALES,
2182         .hardware      = 0,
2183         .fops          = &video_fops,
2184         .minor         = -1,
2185 };
2186
2187 struct video_device saa7134_vbi_template =
2188 {
2189         .name          = "saa7134-vbi",
2190         .type          = VID_TYPE_TUNER|VID_TYPE_TELETEXT,
2191         .hardware      = 0,
2192         .fops          = &video_fops,
2193         .minor         = -1,
2194 };
2195
2196 struct video_device saa7134_radio_template =
2197 {
2198         .name          = "saa7134-radio",
2199         .type          = VID_TYPE_TUNER,
2200         .hardware      = 0,
2201         .fops          = &radio_fops,
2202         .minor         = -1,
2203 };
2204
2205 int saa7134_video_init1(struct saa7134_dev *dev)
2206 {
2207         /* sanitycheck insmod options */
2208         if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
2209                 gbuffers = 2;
2210         if (gbufsize < 0 || gbufsize > gbufsize_max)
2211                 gbufsize = gbufsize_max;
2212         gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
2213
2214         /* put some sensible defaults into the data structures ... */
2215         dev->ctl_bright     = ctrl_by_id(V4L2_CID_BRIGHTNESS)->default_value;
2216         dev->ctl_contrast   = ctrl_by_id(V4L2_CID_CONTRAST)->default_value;
2217         dev->ctl_hue        = ctrl_by_id(V4L2_CID_HUE)->default_value;
2218         dev->ctl_saturation = ctrl_by_id(V4L2_CID_SATURATION)->default_value;
2219         dev->ctl_volume     = ctrl_by_id(V4L2_CID_AUDIO_VOLUME)->default_value;
2220
2221         dev->ctl_invert     = 0;
2222         dev->ctl_mute       = 1;
2223         dev->automute       = 0;
2224
2225         INIT_LIST_HEAD(&dev->video_q.queue);
2226         init_timer(&dev->video_q.timeout);
2227         dev->video_q.timeout.function = saa7134_buffer_timeout;
2228         dev->video_q.timeout.data     = (unsigned long)(&dev->video_q);
2229         dev->video_q.dev              = dev;
2230
2231         if (saa7134_boards[dev->board].video_out) {
2232                 /* enable video output */
2233                 int vo = saa7134_boards[dev->board].video_out;
2234                 saa_writeb(SAA7134_VIDEO_PORT_CTRL0, video_out[vo][0]);
2235                 saa_writeb(SAA7134_VIDEO_PORT_CTRL1, video_out[vo][1]);
2236                 saa_writeb(SAA7134_VIDEO_PORT_CTRL2, video_out[vo][2]);
2237                 saa_writeb(SAA7134_VIDEO_PORT_CTRL3, video_out[vo][3]);
2238                 saa_writeb(SAA7134_VIDEO_PORT_CTRL4, video_out[vo][4]);
2239                 saa_writeb(SAA7134_VIDEO_PORT_CTRL5, video_out[vo][5]);
2240                 saa_writeb(SAA7134_VIDEO_PORT_CTRL6, video_out[vo][6]);
2241                 saa_writeb(SAA7134_VIDEO_PORT_CTRL7, video_out[vo][7]);
2242                 saa_writeb(SAA7134_VIDEO_PORT_CTRL8, video_out[vo][8]);
2243         }
2244
2245         return 0;
2246 }
2247
2248 int saa7134_video_init2(struct saa7134_dev *dev)
2249 {
2250         /* init video hw */
2251         set_tvnorm(dev,&tvnorms[0]);
2252         video_mux(dev,0);
2253         saa7134_tvaudio_setmute(dev);
2254         saa7134_tvaudio_setvolume(dev,dev->ctl_volume);
2255         return 0;
2256 }
2257
2258 int saa7134_video_fini(struct saa7134_dev *dev)
2259 {
2260         /* nothing */
2261         return 0;
2262 }
2263
2264 void saa7134_irq_video_intl(struct saa7134_dev *dev)
2265 {
2266         static const char *st[] = {
2267                 "no signal", "found NTSC", "found PAL", "found SECAM" };
2268         int norm;
2269
2270         norm = saa_readb(SAA7134_STATUS_VIDEO1) & 0x03;
2271         dprintk("DCSDT: %s\n",st[norm]);
2272
2273         if (0 != norm) {
2274                 /* wake up tvaudio audio carrier scan thread */
2275                 saa7134_tvaudio_do_scan(dev);
2276         } else {
2277                 /* no video signal -> mute audio */
2278                 dev->automute = 1;
2279                 saa7134_tvaudio_setmute(dev);
2280         }
2281 }
2282
2283 void saa7134_irq_video_done(struct saa7134_dev *dev, unsigned long status)
2284 {
2285         enum v4l2_field field;
2286
2287         spin_lock(&dev->slock);
2288         if (dev->video_q.curr) {
2289                 dev->video_fieldcount++;
2290                 field = dev->video_q.curr->vb.field;
2291                 if (V4L2_FIELD_HAS_BOTH(field)) {
2292                         /* make sure we have seen both fields */
2293                         if ((status & 0x10) == 0x00) {
2294                                 dev->video_q.curr->top_seen = 1;
2295                                 goto done;
2296                         }
2297                         if (!dev->video_q.curr->top_seen)
2298                                 goto done;
2299                 } else if (field == V4L2_FIELD_TOP) {
2300                         if ((status & 0x10) != 0x10)
2301                                 goto done;
2302                 } else if (field == V4L2_FIELD_BOTTOM) {
2303                         if ((status & 0x10) != 0x00)
2304                                 goto done;
2305                 }
2306                 dev->video_q.curr->vb.field_count = dev->video_fieldcount;
2307                 saa7134_buffer_finish(dev,&dev->video_q,STATE_DONE);
2308         }
2309         saa7134_buffer_next(dev,&dev->video_q);
2310
2311  done:
2312         spin_unlock(&dev->slock);
2313 }
2314
2315 /* ----------------------------------------------------------- */
2316 /*
2317  * Local variables:
2318  * c-basic-offset: 8
2319  * End:
2320  */